diff --git a/.gitignore b/.gitignore index 3275ff833..c3ddb85ab 100644 --- a/.gitignore +++ b/.gitignore @@ -2,7 +2,11 @@ .gradle/ **/build/* +<<<<<<< HEAD !**/avro-fastserde-tests111/build/codegen +======= +!**/build/codegen +>>>>>>> 6f03f254 (Added generated test classes temporarily) #temp artifacts avro_tools/ diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/Array_of_BOOLEAN_GenericDeserializer_869749973_869749973.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/Array_of_BOOLEAN_GenericDeserializer_869749973_869749973.java new file mode 100644 index 000000000..30e63ddfa --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/Array_of_BOOLEAN_GenericDeserializer_869749973_869749973.java @@ -0,0 +1,43 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class Array_of_BOOLEAN_GenericDeserializer_869749973_869749973 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Array_of_BOOLEAN_GenericDeserializer_869749973_869749973(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveBooleanList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveBooleanList) { + array0 = ((PrimitiveBooleanList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveBooleanArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_DOUBLE_GenericDeserializer_18760307_18760307(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveDoubleList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveDoubleList) { + array0 = ((PrimitiveDoubleList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveDoubleArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_FLOAT_GenericDeserializer_1012670397_1012670397(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveFloatList array0 = null; + array0 = ((PrimitiveFloatList) BufferBackedPrimitiveFloatList.readPrimitiveFloatArray((reuse), (decoder))); + return array0; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/Array_of_INT_GenericDeserializer_1012089072_1012089072.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/Array_of_INT_GenericDeserializer_1012089072_1012089072.java new file mode 100644 index 000000000..6812b5037 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/Array_of_INT_GenericDeserializer_1012089072_1012089072.java @@ -0,0 +1,43 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class Array_of_INT_GenericDeserializer_1012089072_1012089072 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Array_of_INT_GenericDeserializer_1012089072_1012089072(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveIntList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveIntList) { + array0 = ((PrimitiveIntList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_LONG_GenericDeserializer_325099267_325099267(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveLongList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveLongList) { + array0 = ((PrimitiveLongList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveLongArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_TestRecord_SpecificDeserializer_1088113243_1088113243(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + if (array0 instanceof GenericArray) { + ((GenericArray) array0).reset(); + } else { + array0 .clear(); + } + } else { + array0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + if (testFixedArray0 instanceof GenericArray) { + ((GenericArray) testFixedArray0).reset(); + } else { + testFixedArray0 .clear(); + } + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + if (testFixedUnionArray0 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray0).reset(); + } else { + testFixedUnionArray0 .clear(); + } + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + if (testEnumArray0 instanceof GenericArray) { + ((GenericArray) testEnumArray0).reset(); + } else { + testEnumArray0 .clear(); + } + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + if (testEnumUnionArray0 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray0).reset(); + } else { + testEnumUnionArray0 .clear(); + } + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + if (recordsArray0 instanceof GenericArray) { + ((GenericArray) recordsArray0).reset(); + } else { + recordsArray0 .clear(); + } + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + if (recordsArrayMap0 instanceof GenericArray) { + ((GenericArray) recordsArrayMap0).reset(); + } else { + recordsArrayMap0 .clear(); + } + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + if (stringArray0 instanceof GenericArray) { + ((GenericArray) stringArray0).reset(); + } else { + stringArray0 .clear(); + } + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema arrayArrayElemSchema0; + private final Schema arrayElemOptionSchema0; + private final Schema field0; + + public Array_of_UNION_GenericDeserializer_777827233_777827233(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArrayElemSchema0 = readerSchema.getElementType(); + this.arrayElemOptionSchema0 = arrayArrayElemSchema0 .getTypes().get(1); + this.field0 = arrayElemOptionSchema0 .getField("field").schema(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + if (array0 instanceof GenericArray) { + ((GenericArray) array0).reset(); + } else { + array0 .clear(); + } + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_UNION_SpecificDeserializer_1277939469_1277939469(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + if (array0 instanceof GenericArray) { + ((GenericArray) array0).reset(); + } else { + array0 .clear(); + } + } else { + array0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + if (testFixedArray0 instanceof GenericArray) { + ((GenericArray) testFixedArray0).reset(); + } else { + testFixedArray0 .clear(); + } + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + if (testFixedUnionArray0 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray0).reset(); + } else { + testFixedUnionArray0 .clear(); + } + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + if (testEnumArray0 instanceof GenericArray) { + ((GenericArray) testEnumArray0).reset(); + } else { + testEnumArray0 .clear(); + } + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + if (testEnumUnionArray0 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray0).reset(); + } else { + testEnumUnionArray0 .clear(); + } + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + if (recordsArray0 instanceof GenericArray) { + ((GenericArray) recordsArray0).reset(); + } else { + recordsArray0 .clear(); + } + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex15 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex17)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + if (recordsArrayMap0 instanceof GenericArray) { + ((GenericArray) recordsArrayMap0).reset(); + } else { + recordsArrayMap0 .clear(); + } + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex21 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex21)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex23 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex23)); + } + } + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex25 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex25 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex25 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex25)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + if (stringArray0 instanceof GenericArray) { + ((GenericArray) stringArray0).reset(); + } else { + stringArray0 .clear(); + } + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema unionOptionArrayElemSchema0; + + public Array_of_record_GenericDeserializer_1606337179_2018567528(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOptionArrayElemSchema0 = readerSchema.getElementType(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":{\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}}"); + } else { + if (unionIndex0 == 1) { + List unionOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + unionOption0 = ((List)(reuse)); + if (unionOption0 instanceof GenericArray) { + ((GenericArray) unionOption0).reset(); + } else { + unionOption0 .clear(); + } + } else { + unionOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + private final Schema arrayArrayElemSchema0; + private final Schema field0; + + public Array_of_record_GenericDeserializer_477614132_477614132(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArrayElemSchema0 = readerSchema.getElementType(); + this.field0 = arrayArrayElemSchema0 .getField("field").schema(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + if (array0 instanceof GenericArray) { + ((GenericArray) array0).reset(); + } else { + array0 .clear(); + } + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema f00; + private final Schema f10; + private final Schema f20; + private final Schema f30; + private final Schema f40; + private final Schema f50; + private final Schema f60; + private final Schema f70; + private final Schema f80; + private final Schema f90; + private final Schema f100; + private final Schema f110; + private final Schema f120; + private final Schema f130; + private final Schema f140; + private final Schema f150; + private final Schema f160; + private final Schema f170; + private final Schema f180; + private final Schema f190; + private final Schema f200; + private final Schema f210; + private final Schema f220; + private final Schema f230; + private final Schema f240; + private final Schema f250; + private final Schema f260; + private final Schema f270; + private final Schema f280; + private final Schema f290; + private final Schema f300; + private final Schema f310; + private final Schema f320; + private final Schema f330; + private final Schema f340; + private final Schema f350; + private final Schema f360; + private final Schema f370; + private final Schema f380; + private final Schema f390; + private final Schema f400; + private final Schema f410; + private final Schema f420; + private final Schema f430; + private final Schema f440; + private final Schema f450; + private final Schema f460; + private final Schema f470; + private final Schema f480; + private final Schema f490; + private final Schema f500; + private final Schema f510; + private final Schema f520; + private final Schema f530; + private final Schema f540; + private final Schema f550; + private final Schema f560; + private final Schema f570; + private final Schema f580; + private final Schema f590; + private final Schema f600; + private final Schema f610; + private final Schema f620; + private final Schema f630; + private final Schema f640; + private final Schema f650; + private final Schema f660; + private final Schema f670; + private final Schema f680; + private final Schema f690; + private final Schema f700; + private final Schema f710; + private final Schema f720; + private final Schema f730; + private final Schema f740; + private final Schema f750; + private final Schema f760; + private final Schema f770; + private final Schema f780; + private final Schema f790; + private final Schema f800; + private final Schema f810; + private final Schema f820; + private final Schema f830; + private final Schema f840; + private final Schema f850; + private final Schema f860; + private final Schema f870; + private final Schema f880; + private final Schema f890; + private final Schema f900; + private final Schema f910; + private final Schema f920; + private final Schema f930; + private final Schema f940; + private final Schema f950; + private final Schema f960; + private final Schema f970; + private final Schema f980; + private final Schema f990; + private final Schema f1000; + private final Schema f1010; + private final Schema f1020; + private final Schema f1030; + private final Schema f1040; + private final Schema f1050; + private final Schema f1060; + private final Schema f1070; + private final Schema f1080; + private final Schema f1090; + private final Schema f1100; + private final Schema f1110; + private final Schema f1120; + private final Schema f1130; + private final Schema f1140; + private final Schema f1150; + private final Schema f1160; + private final Schema f1170; + private final Schema f1180; + private final Schema f1190; + private final Schema f1200; + private final Schema f1210; + private final Schema f1220; + private final Schema f1230; + private final Schema f1240; + private final Schema f1250; + private final Schema f1260; + private final Schema f1270; + private final Schema f1280; + private final Schema f1290; + private final Schema f1300; + private final Schema f1310; + private final Schema f1320; + private final Schema f1330; + private final Schema f1340; + private final Schema f1350; + private final Schema f1360; + private final Schema f1370; + private final Schema f1380; + private final Schema f1390; + private final Schema f1400; + private final Schema f1410; + private final Schema f1420; + private final Schema f1430; + private final Schema f1440; + private final Schema f1450; + private final Schema f1460; + private final Schema f1470; + private final Schema f1480; + private final Schema f1490; + private final Schema f1500; + private final Schema f1510; + private final Schema f1520; + private final Schema f1530; + private final Schema f1540; + private final Schema f1550; + private final Schema f1560; + private final Schema f1570; + private final Schema f1580; + private final Schema f1590; + private final Schema f1600; + private final Schema f1610; + private final Schema f1620; + private final Schema f1630; + private final Schema f1640; + private final Schema f1650; + private final Schema f1660; + private final Schema f1670; + private final Schema f1680; + private final Schema f1690; + private final Schema f1700; + private final Schema f1710; + private final Schema f1720; + private final Schema f1730; + private final Schema f1740; + private final Schema f1750; + private final Schema f1760; + private final Schema f1770; + private final Schema f1780; + private final Schema f1790; + private final Schema f1800; + private final Schema f1810; + private final Schema f1820; + private final Schema f1830; + private final Schema f1840; + private final Schema f1850; + private final Schema f1860; + private final Schema f1870; + private final Schema f1880; + private final Schema f1890; + private final Schema f1900; + private final Schema f1910; + private final Schema f1920; + private final Schema f1930; + private final Schema f1940; + private final Schema f1950; + private final Schema f1960; + private final Schema f1970; + private final Schema f1980; + private final Schema f1990; + private final Schema f2000; + private final Schema f2010; + private final Schema f2020; + private final Schema f2030; + private final Schema f2040; + private final Schema f2050; + private final Schema f2060; + private final Schema f2070; + private final Schema f2080; + private final Schema f2090; + private final Schema f2100; + private final Schema f2110; + private final Schema f2120; + private final Schema f2130; + private final Schema f2140; + private final Schema f2150; + private final Schema f2160; + private final Schema f2170; + private final Schema f2180; + private final Schema f2190; + private final Schema f2200; + private final Schema f2210; + private final Schema f2220; + private final Schema f2230; + private final Schema f2240; + private final Schema f2250; + private final Schema f2260; + private final Schema f2270; + private final Schema f2280; + private final Schema f2290; + private final Schema f2300; + private final Schema f2310; + private final Schema f2320; + private final Schema f2330; + private final Schema f2340; + private final Schema f2350; + private final Schema f2360; + private final Schema f2370; + private final Schema f2380; + private final Schema f2390; + private final Schema f2400; + private final Schema f2410; + private final Schema f2420; + private final Schema f2430; + private final Schema f2440; + private final Schema f2450; + private final Schema f2460; + private final Schema f2470; + private final Schema f2480; + private final Schema f2490; + private final Schema f2500; + private final Schema f2510; + private final Schema f2520; + private final Schema f2530; + private final Schema f2540; + private final Schema f2550; + private final Schema f2560; + private final Schema f2570; + private final Schema f2580; + private final Schema f2590; + private final Schema f2600; + private final Schema f2610; + private final Schema f2620; + private final Schema f2630; + private final Schema f2640; + private final Schema f2650; + private final Schema f2660; + private final Schema f2670; + private final Schema f2680; + private final Schema f2690; + private final Schema f2700; + private final Schema f2710; + private final Schema f2720; + private final Schema f2730; + private final Schema f2740; + private final Schema f2750; + private final Schema f2760; + private final Schema f2770; + private final Schema f2780; + private final Schema f2790; + private final Schema f2800; + private final Schema f2810; + private final Schema f2820; + private final Schema f2830; + private final Schema f2840; + private final Schema f2850; + private final Schema f2860; + private final Schema f2870; + private final Schema f2880; + private final Schema f2890; + private final Schema f2900; + private final Schema f2910; + private final Schema f2920; + private final Schema f2930; + private final Schema f2940; + private final Schema f2950; + private final Schema f2960; + private final Schema f2970; + private final Schema f2980; + private final Schema f2990; + private final Schema f3000; + private final Schema f3010; + private final Schema f3020; + private final Schema f3030; + private final Schema f3040; + private final Schema f3050; + private final Schema f3060; + private final Schema f3070; + private final Schema f3080; + private final Schema f3090; + private final Schema f3100; + private final Schema f3110; + private final Schema f3120; + private final Schema f3130; + private final Schema f3140; + private final Schema f3150; + private final Schema f3160; + private final Schema f3170; + private final Schema f3180; + private final Schema f3190; + private final Schema f3200; + private final Schema f3210; + private final Schema f3220; + private final Schema f3230; + private final Schema f3240; + private final Schema f3250; + private final Schema f3260; + private final Schema f3270; + private final Schema f3280; + private final Schema f3290; + private final Schema f3300; + private final Schema f3310; + private final Schema f3320; + private final Schema f3330; + private final Schema f3340; + private final Schema f3350; + private final Schema f3360; + private final Schema f3370; + private final Schema f3380; + private final Schema f3390; + private final Schema f3400; + private final Schema f3410; + private final Schema f3420; + private final Schema f3430; + private final Schema f3440; + private final Schema f3450; + private final Schema f3460; + private final Schema f3470; + private final Schema f3480; + private final Schema f3490; + private final Schema f3500; + private final Schema f3510; + private final Schema f3520; + private final Schema f3530; + private final Schema f3540; + private final Schema f3550; + private final Schema f3560; + private final Schema f3570; + private final Schema f3580; + private final Schema f3590; + private final Schema f3600; + private final Schema f3610; + private final Schema f3620; + private final Schema f3630; + private final Schema f3640; + private final Schema f3650; + private final Schema f3660; + private final Schema f3670; + private final Schema f3680; + private final Schema f3690; + private final Schema f3700; + private final Schema f3710; + private final Schema f3720; + private final Schema f3730; + private final Schema f3740; + private final Schema f3750; + private final Schema f3760; + private final Schema f3770; + private final Schema f3780; + private final Schema f3790; + private final Schema f3800; + private final Schema f3810; + private final Schema f3820; + private final Schema f3830; + private final Schema f3840; + private final Schema f3850; + private final Schema f3860; + private final Schema f3870; + private final Schema f3880; + private final Schema f3890; + private final Schema f3900; + private final Schema f3910; + private final Schema f3920; + private final Schema f3930; + private final Schema f3940; + private final Schema f3950; + private final Schema f3960; + private final Schema f3970; + private final Schema f3980; + private final Schema f3990; + private final Schema f4000; + private final Schema f4010; + private final Schema f4020; + private final Schema f4030; + private final Schema f4040; + private final Schema f4050; + private final Schema f4060; + private final Schema f4070; + private final Schema f4080; + private final Schema f4090; + private final Schema f4100; + private final Schema f4110; + private final Schema f4120; + private final Schema f4130; + private final Schema f4140; + private final Schema f4150; + private final Schema f4160; + private final Schema f4170; + private final Schema f4180; + private final Schema f4190; + private final Schema f4200; + private final Schema f4210; + private final Schema f4220; + private final Schema f4230; + private final Schema f4240; + private final Schema f4250; + private final Schema f4260; + private final Schema f4270; + private final Schema f4280; + private final Schema f4290; + private final Schema f4300; + private final Schema f4310; + private final Schema f4320; + private final Schema f4330; + private final Schema f4340; + private final Schema f4350; + private final Schema f4360; + private final Schema f4370; + private final Schema f4380; + private final Schema f4390; + private final Schema f4400; + private final Schema f4410; + private final Schema f4420; + private final Schema f4430; + private final Schema f4440; + private final Schema f4450; + private final Schema f4460; + private final Schema f4470; + private final Schema f4480; + private final Schema f4490; + private final Schema f4500; + private final Schema f4510; + private final Schema f4520; + private final Schema f4530; + private final Schema f4540; + private final Schema f4550; + private final Schema f4560; + private final Schema f4570; + private final Schema f4580; + private final Schema f4590; + private final Schema f4600; + private final Schema f4610; + private final Schema f4620; + private final Schema f4630; + private final Schema f4640; + private final Schema f4650; + private final Schema f4660; + private final Schema f4670; + private final Schema f4680; + private final Schema f4690; + private final Schema f4700; + private final Schema f4710; + private final Schema f4720; + private final Schema f4730; + private final Schema f4740; + private final Schema f4750; + private final Schema f4760; + private final Schema f4770; + private final Schema f4780; + private final Schema f4790; + private final Schema f4800; + private final Schema f4810; + private final Schema f4820; + private final Schema f4830; + private final Schema f4840; + private final Schema f4850; + private final Schema f4860; + private final Schema f4870; + private final Schema f4880; + private final Schema f4890; + private final Schema f4900; + private final Schema f4910; + private final Schema f4920; + private final Schema f4930; + private final Schema f4940; + private final Schema f4950; + private final Schema f4960; + private final Schema f4970; + private final Schema f4980; + private final Schema f4990; + private final Schema f5000; + private final Schema f5010; + private final Schema f5020; + private final Schema f5030; + private final Schema f5040; + private final Schema f5050; + private final Schema f5060; + private final Schema f5070; + private final Schema f5080; + private final Schema f5090; + private final Schema f5100; + private final Schema f5110; + private final Schema f5120; + private final Schema f5130; + private final Schema f5140; + private final Schema f5150; + private final Schema f5160; + private final Schema f5170; + private final Schema f5180; + private final Schema f5190; + private final Schema f5200; + private final Schema f5210; + private final Schema f5220; + private final Schema f5230; + private final Schema f5240; + private final Schema f5250; + private final Schema f5260; + private final Schema f5270; + private final Schema f5280; + private final Schema f5290; + private final Schema f5300; + private final Schema f5310; + private final Schema f5320; + private final Schema f5330; + private final Schema f5340; + private final Schema f5350; + private final Schema f5360; + private final Schema f5370; + private final Schema f5380; + private final Schema f5390; + private final Schema f5400; + private final Schema f5410; + private final Schema f5420; + private final Schema f5430; + private final Schema f5440; + private final Schema f5450; + private final Schema f5460; + private final Schema f5470; + private final Schema f5480; + private final Schema f5490; + private final Schema f5500; + private final Schema f5510; + private final Schema f5520; + private final Schema f5530; + private final Schema f5540; + private final Schema f5550; + private final Schema f5560; + private final Schema f5570; + private final Schema f5580; + private final Schema f5590; + private final Schema f5600; + private final Schema f5610; + private final Schema f5620; + private final Schema f5630; + private final Schema f5640; + private final Schema f5650; + private final Schema f5660; + private final Schema f5670; + private final Schema f5680; + private final Schema f5690; + private final Schema f5700; + private final Schema f5710; + private final Schema f5720; + private final Schema f5730; + private final Schema f5740; + private final Schema f5750; + private final Schema f5760; + private final Schema f5770; + private final Schema f5780; + private final Schema f5790; + private final Schema f5800; + private final Schema f5810; + private final Schema f5820; + private final Schema f5830; + private final Schema f5840; + private final Schema f5850; + private final Schema f5860; + private final Schema f5870; + private final Schema f5880; + private final Schema f5890; + private final Schema f5900; + private final Schema f5910; + private final Schema f5920; + private final Schema f5930; + private final Schema f5940; + private final Schema f5950; + private final Schema f5960; + private final Schema f5970; + private final Schema f5980; + private final Schema f5990; + private final Schema f6000; + private final Schema f6010; + private final Schema f6020; + private final Schema f6030; + private final Schema f6040; + private final Schema f6050; + private final Schema f6060; + private final Schema f6070; + private final Schema f6080; + private final Schema f6090; + private final Schema f6100; + private final Schema f6110; + private final Schema f6120; + private final Schema f6130; + private final Schema f6140; + private final Schema f6150; + private final Schema f6160; + private final Schema f6170; + private final Schema f6180; + private final Schema f6190; + private final Schema f6200; + private final Schema f6210; + private final Schema f6220; + private final Schema f6230; + private final Schema f6240; + private final Schema f6250; + private final Schema f6260; + private final Schema f6270; + private final Schema f6280; + private final Schema f6290; + private final Schema f6300; + private final Schema f6310; + private final Schema f6320; + private final Schema f6330; + private final Schema f6340; + private final Schema f6350; + private final Schema f6360; + private final Schema f6370; + private final Schema f6380; + private final Schema f6390; + private final Schema f6400; + private final Schema f6410; + private final Schema f6420; + private final Schema f6430; + private final Schema f6440; + private final Schema f6450; + private final Schema f6460; + private final Schema f6470; + private final Schema f6480; + private final Schema f6490; + private final Schema f6500; + private final Schema f6510; + private final Schema f6520; + private final Schema f6530; + private final Schema f6540; + private final Schema f6550; + private final Schema f6560; + private final Schema f6570; + private final Schema f6580; + private final Schema f6590; + private final Schema f6600; + private final Schema f6610; + private final Schema f6620; + private final Schema f6630; + private final Schema f6640; + private final Schema f6650; + private final Schema f6660; + private final Schema f6670; + private final Schema f6680; + private final Schema f6690; + private final Schema f6700; + private final Schema f6710; + private final Schema f6720; + private final Schema f6730; + private final Schema f6740; + private final Schema f6750; + private final Schema f6760; + private final Schema f6770; + private final Schema f6780; + private final Schema f6790; + private final Schema f6800; + private final Schema f6810; + private final Schema f6820; + private final Schema f6830; + private final Schema f6840; + private final Schema f6850; + private final Schema f6860; + private final Schema f6870; + private final Schema f6880; + private final Schema f6890; + private final Schema f6900; + private final Schema f6910; + private final Schema f6920; + private final Schema f6930; + private final Schema f6940; + private final Schema f6950; + private final Schema f6960; + private final Schema f6970; + private final Schema f6980; + private final Schema f6990; + private final Schema f7000; + private final Schema f7010; + private final Schema f7020; + private final Schema f7030; + private final Schema f7040; + private final Schema f7050; + private final Schema f7060; + private final Schema f7070; + private final Schema f7080; + private final Schema f7090; + private final Schema f7100; + private final Schema f7110; + private final Schema f7120; + private final Schema f7130; + private final Schema f7140; + private final Schema f7150; + private final Schema f7160; + private final Schema f7170; + private final Schema f7180; + private final Schema f7190; + private final Schema f7200; + private final Schema f7210; + private final Schema f7220; + private final Schema f7230; + private final Schema f7240; + private final Schema f7250; + private final Schema f7260; + private final Schema f7270; + private final Schema f7280; + private final Schema f7290; + private final Schema f7300; + private final Schema f7310; + private final Schema f7320; + private final Schema f7330; + private final Schema f7340; + private final Schema f7350; + private final Schema f7360; + private final Schema f7370; + private final Schema f7380; + private final Schema f7390; + private final Schema f7400; + private final Schema f7410; + private final Schema f7420; + private final Schema f7430; + private final Schema f7440; + private final Schema f7450; + private final Schema f7460; + private final Schema f7470; + private final Schema f7480; + private final Schema f7490; + private final Schema f7500; + private final Schema f7510; + private final Schema f7520; + private final Schema f7530; + private final Schema f7540; + private final Schema f7550; + private final Schema f7560; + private final Schema f7570; + private final Schema f7580; + private final Schema f7590; + private final Schema f7600; + private final Schema f7610; + private final Schema f7620; + private final Schema f7630; + private final Schema f7640; + private final Schema f7650; + private final Schema f7660; + private final Schema f7670; + private final Schema f7680; + private final Schema f7690; + private final Schema f7700; + private final Schema f7710; + private final Schema f7720; + private final Schema f7730; + private final Schema f7740; + private final Schema f7750; + private final Schema f7760; + private final Schema f7770; + private final Schema f7780; + private final Schema f7790; + private final Schema f7800; + private final Schema f7810; + private final Schema f7820; + private final Schema f7830; + private final Schema f7840; + private final Schema f7850; + private final Schema f7860; + private final Schema f7870; + private final Schema f7880; + private final Schema f7890; + private final Schema f7900; + private final Schema f7910; + private final Schema f7920; + private final Schema f7930; + private final Schema f7940; + private final Schema f7950; + private final Schema f7960; + private final Schema f7970; + private final Schema f7980; + private final Schema f7990; + private final Schema f8000; + private final Schema f8010; + private final Schema f8020; + private final Schema f8030; + private final Schema f8040; + private final Schema f8050; + private final Schema f8060; + private final Schema f8070; + private final Schema f8080; + private final Schema f8090; + private final Schema f8100; + private final Schema f8110; + private final Schema f8120; + private final Schema f8130; + private final Schema f8140; + private final Schema f8150; + private final Schema f8160; + private final Schema f8170; + private final Schema f8180; + private final Schema f8190; + private final Schema f8200; + private final Schema f8210; + private final Schema f8220; + private final Schema f8230; + private final Schema f8240; + private final Schema f8250; + private final Schema f8260; + private final Schema f8270; + private final Schema f8280; + private final Schema f8290; + private final Schema f8300; + private final Schema f8310; + private final Schema f8320; + private final Schema f8330; + private final Schema f8340; + private final Schema f8350; + private final Schema f8360; + private final Schema f8370; + private final Schema f8380; + private final Schema f8390; + private final Schema f8400; + private final Schema f8410; + private final Schema f8420; + private final Schema f8430; + private final Schema f8440; + private final Schema f8450; + private final Schema f8460; + private final Schema f8470; + private final Schema f8480; + private final Schema f8490; + private final Schema f8500; + private final Schema f8510; + private final Schema f8520; + private final Schema f8530; + private final Schema f8540; + private final Schema f8550; + private final Schema f8560; + private final Schema f8570; + private final Schema f8580; + private final Schema f8590; + private final Schema f8600; + private final Schema f8610; + private final Schema f8620; + private final Schema f8630; + private final Schema f8640; + private final Schema f8650; + private final Schema f8660; + private final Schema f8670; + private final Schema f8680; + private final Schema f8690; + private final Schema f8700; + private final Schema f8710; + private final Schema f8720; + private final Schema f8730; + private final Schema f8740; + private final Schema f8750; + private final Schema f8760; + private final Schema f8770; + private final Schema f8780; + private final Schema f8790; + private final Schema f8800; + private final Schema f8810; + private final Schema f8820; + private final Schema f8830; + private final Schema f8840; + private final Schema f8850; + private final Schema f8860; + private final Schema f8870; + private final Schema f8880; + private final Schema f8890; + private final Schema f8900; + private final Schema f8910; + private final Schema f8920; + private final Schema f8930; + private final Schema f8940; + private final Schema f8950; + private final Schema f8960; + private final Schema f8970; + private final Schema f8980; + private final Schema f8990; + private final Schema f9000; + private final Schema f9010; + private final Schema f9020; + private final Schema f9030; + private final Schema f9040; + private final Schema f9050; + private final Schema f9060; + private final Schema f9070; + private final Schema f9080; + private final Schema f9090; + private final Schema f9100; + private final Schema f9110; + private final Schema f9120; + private final Schema f9130; + private final Schema f9140; + private final Schema f9150; + private final Schema f9160; + private final Schema f9170; + private final Schema f9180; + private final Schema f9190; + private final Schema f9200; + private final Schema f9210; + private final Schema f9220; + private final Schema f9230; + private final Schema f9240; + private final Schema f9250; + private final Schema f9260; + private final Schema f9270; + private final Schema f9280; + private final Schema f9290; + private final Schema f9300; + private final Schema f9310; + private final Schema f9320; + private final Schema f9330; + private final Schema f9340; + private final Schema f9350; + private final Schema f9360; + private final Schema f9370; + private final Schema f9380; + private final Schema f9390; + private final Schema f9400; + private final Schema f9410; + private final Schema f9420; + private final Schema f9430; + private final Schema f9440; + private final Schema f9450; + private final Schema f9460; + private final Schema f9470; + private final Schema f9480; + private final Schema f9490; + private final Schema f9500; + private final Schema f9510; + private final Schema f9520; + private final Schema f9530; + private final Schema f9540; + private final Schema f9550; + private final Schema f9560; + private final Schema f9570; + private final Schema f9580; + private final Schema f9590; + private final Schema f9600; + private final Schema f9610; + private final Schema f9620; + private final Schema f9630; + private final Schema f9640; + private final Schema f9650; + private final Schema f9660; + private final Schema f9670; + private final Schema f9680; + private final Schema f9690; + private final Schema f9700; + private final Schema f9710; + private final Schema f9720; + private final Schema f9730; + private final Schema f9740; + private final Schema f9750; + private final Schema f9760; + private final Schema f9770; + private final Schema f9780; + private final Schema f9790; + private final Schema f9800; + private final Schema f9810; + private final Schema f9820; + private final Schema f9830; + private final Schema f9840; + private final Schema f9850; + private final Schema f9860; + private final Schema f9870; + private final Schema f9880; + private final Schema f9890; + private final Schema f9900; + private final Schema f9910; + private final Schema f9920; + private final Schema f9930; + private final Schema f9940; + private final Schema f9950; + private final Schema f9960; + private final Schema f9970; + private final Schema f9980; + private final Schema f9990; + + public FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema_GenericDeserializer_836892732_836892732(Schema readerSchema) { + this.readerSchema = readerSchema; + this.f00 = readerSchema.getField("F0").schema(); + this.f10 = readerSchema.getField("F1").schema(); + this.f20 = readerSchema.getField("F2").schema(); + this.f30 = readerSchema.getField("F3").schema(); + this.f40 = readerSchema.getField("F4").schema(); + this.f50 = readerSchema.getField("F5").schema(); + this.f60 = readerSchema.getField("F6").schema(); + this.f70 = readerSchema.getField("F7").schema(); + this.f80 = readerSchema.getField("F8").schema(); + this.f90 = readerSchema.getField("F9").schema(); + this.f100 = readerSchema.getField("F10").schema(); + this.f110 = readerSchema.getField("F11").schema(); + this.f120 = readerSchema.getField("F12").schema(); + this.f130 = readerSchema.getField("F13").schema(); + this.f140 = readerSchema.getField("F14").schema(); + this.f150 = readerSchema.getField("F15").schema(); + this.f160 = readerSchema.getField("F16").schema(); + this.f170 = readerSchema.getField("F17").schema(); + this.f180 = readerSchema.getField("F18").schema(); + this.f190 = readerSchema.getField("F19").schema(); + this.f200 = readerSchema.getField("F20").schema(); + this.f210 = readerSchema.getField("F21").schema(); + this.f220 = readerSchema.getField("F22").schema(); + this.f230 = readerSchema.getField("F23").schema(); + this.f240 = readerSchema.getField("F24").schema(); + this.f250 = readerSchema.getField("F25").schema(); + this.f260 = readerSchema.getField("F26").schema(); + this.f270 = readerSchema.getField("F27").schema(); + this.f280 = readerSchema.getField("F28").schema(); + this.f290 = readerSchema.getField("F29").schema(); + this.f300 = readerSchema.getField("F30").schema(); + this.f310 = readerSchema.getField("F31").schema(); + this.f320 = readerSchema.getField("F32").schema(); + this.f330 = readerSchema.getField("F33").schema(); + this.f340 = readerSchema.getField("F34").schema(); + this.f350 = readerSchema.getField("F35").schema(); + this.f360 = readerSchema.getField("F36").schema(); + this.f370 = readerSchema.getField("F37").schema(); + this.f380 = readerSchema.getField("F38").schema(); + this.f390 = readerSchema.getField("F39").schema(); + this.f400 = readerSchema.getField("F40").schema(); + this.f410 = readerSchema.getField("F41").schema(); + this.f420 = readerSchema.getField("F42").schema(); + this.f430 = readerSchema.getField("F43").schema(); + this.f440 = readerSchema.getField("F44").schema(); + this.f450 = readerSchema.getField("F45").schema(); + this.f460 = readerSchema.getField("F46").schema(); + this.f470 = readerSchema.getField("F47").schema(); + this.f480 = readerSchema.getField("F48").schema(); + this.f490 = readerSchema.getField("F49").schema(); + this.f500 = readerSchema.getField("F50").schema(); + this.f510 = readerSchema.getField("F51").schema(); + this.f520 = readerSchema.getField("F52").schema(); + this.f530 = readerSchema.getField("F53").schema(); + this.f540 = readerSchema.getField("F54").schema(); + this.f550 = readerSchema.getField("F55").schema(); + this.f560 = readerSchema.getField("F56").schema(); + this.f570 = readerSchema.getField("F57").schema(); + this.f580 = readerSchema.getField("F58").schema(); + this.f590 = readerSchema.getField("F59").schema(); + this.f600 = readerSchema.getField("F60").schema(); + this.f610 = readerSchema.getField("F61").schema(); + this.f620 = readerSchema.getField("F62").schema(); + this.f630 = readerSchema.getField("F63").schema(); + this.f640 = readerSchema.getField("F64").schema(); + this.f650 = readerSchema.getField("F65").schema(); + this.f660 = readerSchema.getField("F66").schema(); + this.f670 = readerSchema.getField("F67").schema(); + this.f680 = readerSchema.getField("F68").schema(); + this.f690 = readerSchema.getField("F69").schema(); + this.f700 = readerSchema.getField("F70").schema(); + this.f710 = readerSchema.getField("F71").schema(); + this.f720 = readerSchema.getField("F72").schema(); + this.f730 = readerSchema.getField("F73").schema(); + this.f740 = readerSchema.getField("F74").schema(); + this.f750 = readerSchema.getField("F75").schema(); + this.f760 = readerSchema.getField("F76").schema(); + this.f770 = readerSchema.getField("F77").schema(); + this.f780 = readerSchema.getField("F78").schema(); + this.f790 = readerSchema.getField("F79").schema(); + this.f800 = readerSchema.getField("F80").schema(); + this.f810 = readerSchema.getField("F81").schema(); + this.f820 = readerSchema.getField("F82").schema(); + this.f830 = readerSchema.getField("F83").schema(); + this.f840 = readerSchema.getField("F84").schema(); + this.f850 = readerSchema.getField("F85").schema(); + this.f860 = readerSchema.getField("F86").schema(); + this.f870 = readerSchema.getField("F87").schema(); + this.f880 = readerSchema.getField("F88").schema(); + this.f890 = readerSchema.getField("F89").schema(); + this.f900 = readerSchema.getField("F90").schema(); + this.f910 = readerSchema.getField("F91").schema(); + this.f920 = readerSchema.getField("F92").schema(); + this.f930 = readerSchema.getField("F93").schema(); + this.f940 = readerSchema.getField("F94").schema(); + this.f950 = readerSchema.getField("F95").schema(); + this.f960 = readerSchema.getField("F96").schema(); + this.f970 = readerSchema.getField("F97").schema(); + this.f980 = readerSchema.getField("F98").schema(); + this.f990 = readerSchema.getField("F99").schema(); + this.f1000 = readerSchema.getField("F100").schema(); + this.f1010 = readerSchema.getField("F101").schema(); + this.f1020 = readerSchema.getField("F102").schema(); + this.f1030 = readerSchema.getField("F103").schema(); + this.f1040 = readerSchema.getField("F104").schema(); + this.f1050 = readerSchema.getField("F105").schema(); + this.f1060 = readerSchema.getField("F106").schema(); + this.f1070 = readerSchema.getField("F107").schema(); + this.f1080 = readerSchema.getField("F108").schema(); + this.f1090 = readerSchema.getField("F109").schema(); + this.f1100 = readerSchema.getField("F110").schema(); + this.f1110 = readerSchema.getField("F111").schema(); + this.f1120 = readerSchema.getField("F112").schema(); + this.f1130 = readerSchema.getField("F113").schema(); + this.f1140 = readerSchema.getField("F114").schema(); + this.f1150 = readerSchema.getField("F115").schema(); + this.f1160 = readerSchema.getField("F116").schema(); + this.f1170 = readerSchema.getField("F117").schema(); + this.f1180 = readerSchema.getField("F118").schema(); + this.f1190 = readerSchema.getField("F119").schema(); + this.f1200 = readerSchema.getField("F120").schema(); + this.f1210 = readerSchema.getField("F121").schema(); + this.f1220 = readerSchema.getField("F122").schema(); + this.f1230 = readerSchema.getField("F123").schema(); + this.f1240 = readerSchema.getField("F124").schema(); + this.f1250 = readerSchema.getField("F125").schema(); + this.f1260 = readerSchema.getField("F126").schema(); + this.f1270 = readerSchema.getField("F127").schema(); + this.f1280 = readerSchema.getField("F128").schema(); + this.f1290 = readerSchema.getField("F129").schema(); + this.f1300 = readerSchema.getField("F130").schema(); + this.f1310 = readerSchema.getField("F131").schema(); + this.f1320 = readerSchema.getField("F132").schema(); + this.f1330 = readerSchema.getField("F133").schema(); + this.f1340 = readerSchema.getField("F134").schema(); + this.f1350 = readerSchema.getField("F135").schema(); + this.f1360 = readerSchema.getField("F136").schema(); + this.f1370 = readerSchema.getField("F137").schema(); + this.f1380 = readerSchema.getField("F138").schema(); + this.f1390 = readerSchema.getField("F139").schema(); + this.f1400 = readerSchema.getField("F140").schema(); + this.f1410 = readerSchema.getField("F141").schema(); + this.f1420 = readerSchema.getField("F142").schema(); + this.f1430 = readerSchema.getField("F143").schema(); + this.f1440 = readerSchema.getField("F144").schema(); + this.f1450 = readerSchema.getField("F145").schema(); + this.f1460 = readerSchema.getField("F146").schema(); + this.f1470 = readerSchema.getField("F147").schema(); + this.f1480 = readerSchema.getField("F148").schema(); + this.f1490 = readerSchema.getField("F149").schema(); + this.f1500 = readerSchema.getField("F150").schema(); + this.f1510 = readerSchema.getField("F151").schema(); + this.f1520 = readerSchema.getField("F152").schema(); + this.f1530 = readerSchema.getField("F153").schema(); + this.f1540 = readerSchema.getField("F154").schema(); + this.f1550 = readerSchema.getField("F155").schema(); + this.f1560 = readerSchema.getField("F156").schema(); + this.f1570 = readerSchema.getField("F157").schema(); + this.f1580 = readerSchema.getField("F158").schema(); + this.f1590 = readerSchema.getField("F159").schema(); + this.f1600 = readerSchema.getField("F160").schema(); + this.f1610 = readerSchema.getField("F161").schema(); + this.f1620 = readerSchema.getField("F162").schema(); + this.f1630 = readerSchema.getField("F163").schema(); + this.f1640 = readerSchema.getField("F164").schema(); + this.f1650 = readerSchema.getField("F165").schema(); + this.f1660 = readerSchema.getField("F166").schema(); + this.f1670 = readerSchema.getField("F167").schema(); + this.f1680 = readerSchema.getField("F168").schema(); + this.f1690 = readerSchema.getField("F169").schema(); + this.f1700 = readerSchema.getField("F170").schema(); + this.f1710 = readerSchema.getField("F171").schema(); + this.f1720 = readerSchema.getField("F172").schema(); + this.f1730 = readerSchema.getField("F173").schema(); + this.f1740 = readerSchema.getField("F174").schema(); + this.f1750 = readerSchema.getField("F175").schema(); + this.f1760 = readerSchema.getField("F176").schema(); + this.f1770 = readerSchema.getField("F177").schema(); + this.f1780 = readerSchema.getField("F178").schema(); + this.f1790 = readerSchema.getField("F179").schema(); + this.f1800 = readerSchema.getField("F180").schema(); + this.f1810 = readerSchema.getField("F181").schema(); + this.f1820 = readerSchema.getField("F182").schema(); + this.f1830 = readerSchema.getField("F183").schema(); + this.f1840 = readerSchema.getField("F184").schema(); + this.f1850 = readerSchema.getField("F185").schema(); + this.f1860 = readerSchema.getField("F186").schema(); + this.f1870 = readerSchema.getField("F187").schema(); + this.f1880 = readerSchema.getField("F188").schema(); + this.f1890 = readerSchema.getField("F189").schema(); + this.f1900 = readerSchema.getField("F190").schema(); + this.f1910 = readerSchema.getField("F191").schema(); + this.f1920 = readerSchema.getField("F192").schema(); + this.f1930 = readerSchema.getField("F193").schema(); + this.f1940 = readerSchema.getField("F194").schema(); + this.f1950 = readerSchema.getField("F195").schema(); + this.f1960 = readerSchema.getField("F196").schema(); + this.f1970 = readerSchema.getField("F197").schema(); + this.f1980 = readerSchema.getField("F198").schema(); + this.f1990 = readerSchema.getField("F199").schema(); + this.f2000 = readerSchema.getField("F200").schema(); + this.f2010 = readerSchema.getField("F201").schema(); + this.f2020 = readerSchema.getField("F202").schema(); + this.f2030 = readerSchema.getField("F203").schema(); + this.f2040 = readerSchema.getField("F204").schema(); + this.f2050 = readerSchema.getField("F205").schema(); + this.f2060 = readerSchema.getField("F206").schema(); + this.f2070 = readerSchema.getField("F207").schema(); + this.f2080 = readerSchema.getField("F208").schema(); + this.f2090 = readerSchema.getField("F209").schema(); + this.f2100 = readerSchema.getField("F210").schema(); + this.f2110 = readerSchema.getField("F211").schema(); + this.f2120 = readerSchema.getField("F212").schema(); + this.f2130 = readerSchema.getField("F213").schema(); + this.f2140 = readerSchema.getField("F214").schema(); + this.f2150 = readerSchema.getField("F215").schema(); + this.f2160 = readerSchema.getField("F216").schema(); + this.f2170 = readerSchema.getField("F217").schema(); + this.f2180 = readerSchema.getField("F218").schema(); + this.f2190 = readerSchema.getField("F219").schema(); + this.f2200 = readerSchema.getField("F220").schema(); + this.f2210 = readerSchema.getField("F221").schema(); + this.f2220 = readerSchema.getField("F222").schema(); + this.f2230 = readerSchema.getField("F223").schema(); + this.f2240 = readerSchema.getField("F224").schema(); + this.f2250 = readerSchema.getField("F225").schema(); + this.f2260 = readerSchema.getField("F226").schema(); + this.f2270 = readerSchema.getField("F227").schema(); + this.f2280 = readerSchema.getField("F228").schema(); + this.f2290 = readerSchema.getField("F229").schema(); + this.f2300 = readerSchema.getField("F230").schema(); + this.f2310 = readerSchema.getField("F231").schema(); + this.f2320 = readerSchema.getField("F232").schema(); + this.f2330 = readerSchema.getField("F233").schema(); + this.f2340 = readerSchema.getField("F234").schema(); + this.f2350 = readerSchema.getField("F235").schema(); + this.f2360 = readerSchema.getField("F236").schema(); + this.f2370 = readerSchema.getField("F237").schema(); + this.f2380 = readerSchema.getField("F238").schema(); + this.f2390 = readerSchema.getField("F239").schema(); + this.f2400 = readerSchema.getField("F240").schema(); + this.f2410 = readerSchema.getField("F241").schema(); + this.f2420 = readerSchema.getField("F242").schema(); + this.f2430 = readerSchema.getField("F243").schema(); + this.f2440 = readerSchema.getField("F244").schema(); + this.f2450 = readerSchema.getField("F245").schema(); + this.f2460 = readerSchema.getField("F246").schema(); + this.f2470 = readerSchema.getField("F247").schema(); + this.f2480 = readerSchema.getField("F248").schema(); + this.f2490 = readerSchema.getField("F249").schema(); + this.f2500 = readerSchema.getField("F250").schema(); + this.f2510 = readerSchema.getField("F251").schema(); + this.f2520 = readerSchema.getField("F252").schema(); + this.f2530 = readerSchema.getField("F253").schema(); + this.f2540 = readerSchema.getField("F254").schema(); + this.f2550 = readerSchema.getField("F255").schema(); + this.f2560 = readerSchema.getField("F256").schema(); + this.f2570 = readerSchema.getField("F257").schema(); + this.f2580 = readerSchema.getField("F258").schema(); + this.f2590 = readerSchema.getField("F259").schema(); + this.f2600 = readerSchema.getField("F260").schema(); + this.f2610 = readerSchema.getField("F261").schema(); + this.f2620 = readerSchema.getField("F262").schema(); + this.f2630 = readerSchema.getField("F263").schema(); + this.f2640 = readerSchema.getField("F264").schema(); + this.f2650 = readerSchema.getField("F265").schema(); + this.f2660 = readerSchema.getField("F266").schema(); + this.f2670 = readerSchema.getField("F267").schema(); + this.f2680 = readerSchema.getField("F268").schema(); + this.f2690 = readerSchema.getField("F269").schema(); + this.f2700 = readerSchema.getField("F270").schema(); + this.f2710 = readerSchema.getField("F271").schema(); + this.f2720 = readerSchema.getField("F272").schema(); + this.f2730 = readerSchema.getField("F273").schema(); + this.f2740 = readerSchema.getField("F274").schema(); + this.f2750 = readerSchema.getField("F275").schema(); + this.f2760 = readerSchema.getField("F276").schema(); + this.f2770 = readerSchema.getField("F277").schema(); + this.f2780 = readerSchema.getField("F278").schema(); + this.f2790 = readerSchema.getField("F279").schema(); + this.f2800 = readerSchema.getField("F280").schema(); + this.f2810 = readerSchema.getField("F281").schema(); + this.f2820 = readerSchema.getField("F282").schema(); + this.f2830 = readerSchema.getField("F283").schema(); + this.f2840 = readerSchema.getField("F284").schema(); + this.f2850 = readerSchema.getField("F285").schema(); + this.f2860 = readerSchema.getField("F286").schema(); + this.f2870 = readerSchema.getField("F287").schema(); + this.f2880 = readerSchema.getField("F288").schema(); + this.f2890 = readerSchema.getField("F289").schema(); + this.f2900 = readerSchema.getField("F290").schema(); + this.f2910 = readerSchema.getField("F291").schema(); + this.f2920 = readerSchema.getField("F292").schema(); + this.f2930 = readerSchema.getField("F293").schema(); + this.f2940 = readerSchema.getField("F294").schema(); + this.f2950 = readerSchema.getField("F295").schema(); + this.f2960 = readerSchema.getField("F296").schema(); + this.f2970 = readerSchema.getField("F297").schema(); + this.f2980 = readerSchema.getField("F298").schema(); + this.f2990 = readerSchema.getField("F299").schema(); + this.f3000 = readerSchema.getField("F300").schema(); + this.f3010 = readerSchema.getField("F301").schema(); + this.f3020 = readerSchema.getField("F302").schema(); + this.f3030 = readerSchema.getField("F303").schema(); + this.f3040 = readerSchema.getField("F304").schema(); + this.f3050 = readerSchema.getField("F305").schema(); + this.f3060 = readerSchema.getField("F306").schema(); + this.f3070 = readerSchema.getField("F307").schema(); + this.f3080 = readerSchema.getField("F308").schema(); + this.f3090 = readerSchema.getField("F309").schema(); + this.f3100 = readerSchema.getField("F310").schema(); + this.f3110 = readerSchema.getField("F311").schema(); + this.f3120 = readerSchema.getField("F312").schema(); + this.f3130 = readerSchema.getField("F313").schema(); + this.f3140 = readerSchema.getField("F314").schema(); + this.f3150 = readerSchema.getField("F315").schema(); + this.f3160 = readerSchema.getField("F316").schema(); + this.f3170 = readerSchema.getField("F317").schema(); + this.f3180 = readerSchema.getField("F318").schema(); + this.f3190 = readerSchema.getField("F319").schema(); + this.f3200 = readerSchema.getField("F320").schema(); + this.f3210 = readerSchema.getField("F321").schema(); + this.f3220 = readerSchema.getField("F322").schema(); + this.f3230 = readerSchema.getField("F323").schema(); + this.f3240 = readerSchema.getField("F324").schema(); + this.f3250 = readerSchema.getField("F325").schema(); + this.f3260 = readerSchema.getField("F326").schema(); + this.f3270 = readerSchema.getField("F327").schema(); + this.f3280 = readerSchema.getField("F328").schema(); + this.f3290 = readerSchema.getField("F329").schema(); + this.f3300 = readerSchema.getField("F330").schema(); + this.f3310 = readerSchema.getField("F331").schema(); + this.f3320 = readerSchema.getField("F332").schema(); + this.f3330 = readerSchema.getField("F333").schema(); + this.f3340 = readerSchema.getField("F334").schema(); + this.f3350 = readerSchema.getField("F335").schema(); + this.f3360 = readerSchema.getField("F336").schema(); + this.f3370 = readerSchema.getField("F337").schema(); + this.f3380 = readerSchema.getField("F338").schema(); + this.f3390 = readerSchema.getField("F339").schema(); + this.f3400 = readerSchema.getField("F340").schema(); + this.f3410 = readerSchema.getField("F341").schema(); + this.f3420 = readerSchema.getField("F342").schema(); + this.f3430 = readerSchema.getField("F343").schema(); + this.f3440 = readerSchema.getField("F344").schema(); + this.f3450 = readerSchema.getField("F345").schema(); + this.f3460 = readerSchema.getField("F346").schema(); + this.f3470 = readerSchema.getField("F347").schema(); + this.f3480 = readerSchema.getField("F348").schema(); + this.f3490 = readerSchema.getField("F349").schema(); + this.f3500 = readerSchema.getField("F350").schema(); + this.f3510 = readerSchema.getField("F351").schema(); + this.f3520 = readerSchema.getField("F352").schema(); + this.f3530 = readerSchema.getField("F353").schema(); + this.f3540 = readerSchema.getField("F354").schema(); + this.f3550 = readerSchema.getField("F355").schema(); + this.f3560 = readerSchema.getField("F356").schema(); + this.f3570 = readerSchema.getField("F357").schema(); + this.f3580 = readerSchema.getField("F358").schema(); + this.f3590 = readerSchema.getField("F359").schema(); + this.f3600 = readerSchema.getField("F360").schema(); + this.f3610 = readerSchema.getField("F361").schema(); + this.f3620 = readerSchema.getField("F362").schema(); + this.f3630 = readerSchema.getField("F363").schema(); + this.f3640 = readerSchema.getField("F364").schema(); + this.f3650 = readerSchema.getField("F365").schema(); + this.f3660 = readerSchema.getField("F366").schema(); + this.f3670 = readerSchema.getField("F367").schema(); + this.f3680 = readerSchema.getField("F368").schema(); + this.f3690 = readerSchema.getField("F369").schema(); + this.f3700 = readerSchema.getField("F370").schema(); + this.f3710 = readerSchema.getField("F371").schema(); + this.f3720 = readerSchema.getField("F372").schema(); + this.f3730 = readerSchema.getField("F373").schema(); + this.f3740 = readerSchema.getField("F374").schema(); + this.f3750 = readerSchema.getField("F375").schema(); + this.f3760 = readerSchema.getField("F376").schema(); + this.f3770 = readerSchema.getField("F377").schema(); + this.f3780 = readerSchema.getField("F378").schema(); + this.f3790 = readerSchema.getField("F379").schema(); + this.f3800 = readerSchema.getField("F380").schema(); + this.f3810 = readerSchema.getField("F381").schema(); + this.f3820 = readerSchema.getField("F382").schema(); + this.f3830 = readerSchema.getField("F383").schema(); + this.f3840 = readerSchema.getField("F384").schema(); + this.f3850 = readerSchema.getField("F385").schema(); + this.f3860 = readerSchema.getField("F386").schema(); + this.f3870 = readerSchema.getField("F387").schema(); + this.f3880 = readerSchema.getField("F388").schema(); + this.f3890 = readerSchema.getField("F389").schema(); + this.f3900 = readerSchema.getField("F390").schema(); + this.f3910 = readerSchema.getField("F391").schema(); + this.f3920 = readerSchema.getField("F392").schema(); + this.f3930 = readerSchema.getField("F393").schema(); + this.f3940 = readerSchema.getField("F394").schema(); + this.f3950 = readerSchema.getField("F395").schema(); + this.f3960 = readerSchema.getField("F396").schema(); + this.f3970 = readerSchema.getField("F397").schema(); + this.f3980 = readerSchema.getField("F398").schema(); + this.f3990 = readerSchema.getField("F399").schema(); + this.f4000 = readerSchema.getField("F400").schema(); + this.f4010 = readerSchema.getField("F401").schema(); + this.f4020 = readerSchema.getField("F402").schema(); + this.f4030 = readerSchema.getField("F403").schema(); + this.f4040 = readerSchema.getField("F404").schema(); + this.f4050 = readerSchema.getField("F405").schema(); + this.f4060 = readerSchema.getField("F406").schema(); + this.f4070 = readerSchema.getField("F407").schema(); + this.f4080 = readerSchema.getField("F408").schema(); + this.f4090 = readerSchema.getField("F409").schema(); + this.f4100 = readerSchema.getField("F410").schema(); + this.f4110 = readerSchema.getField("F411").schema(); + this.f4120 = readerSchema.getField("F412").schema(); + this.f4130 = readerSchema.getField("F413").schema(); + this.f4140 = readerSchema.getField("F414").schema(); + this.f4150 = readerSchema.getField("F415").schema(); + this.f4160 = readerSchema.getField("F416").schema(); + this.f4170 = readerSchema.getField("F417").schema(); + this.f4180 = readerSchema.getField("F418").schema(); + this.f4190 = readerSchema.getField("F419").schema(); + this.f4200 = readerSchema.getField("F420").schema(); + this.f4210 = readerSchema.getField("F421").schema(); + this.f4220 = readerSchema.getField("F422").schema(); + this.f4230 = readerSchema.getField("F423").schema(); + this.f4240 = readerSchema.getField("F424").schema(); + this.f4250 = readerSchema.getField("F425").schema(); + this.f4260 = readerSchema.getField("F426").schema(); + this.f4270 = readerSchema.getField("F427").schema(); + this.f4280 = readerSchema.getField("F428").schema(); + this.f4290 = readerSchema.getField("F429").schema(); + this.f4300 = readerSchema.getField("F430").schema(); + this.f4310 = readerSchema.getField("F431").schema(); + this.f4320 = readerSchema.getField("F432").schema(); + this.f4330 = readerSchema.getField("F433").schema(); + this.f4340 = readerSchema.getField("F434").schema(); + this.f4350 = readerSchema.getField("F435").schema(); + this.f4360 = readerSchema.getField("F436").schema(); + this.f4370 = readerSchema.getField("F437").schema(); + this.f4380 = readerSchema.getField("F438").schema(); + this.f4390 = readerSchema.getField("F439").schema(); + this.f4400 = readerSchema.getField("F440").schema(); + this.f4410 = readerSchema.getField("F441").schema(); + this.f4420 = readerSchema.getField("F442").schema(); + this.f4430 = readerSchema.getField("F443").schema(); + this.f4440 = readerSchema.getField("F444").schema(); + this.f4450 = readerSchema.getField("F445").schema(); + this.f4460 = readerSchema.getField("F446").schema(); + this.f4470 = readerSchema.getField("F447").schema(); + this.f4480 = readerSchema.getField("F448").schema(); + this.f4490 = readerSchema.getField("F449").schema(); + this.f4500 = readerSchema.getField("F450").schema(); + this.f4510 = readerSchema.getField("F451").schema(); + this.f4520 = readerSchema.getField("F452").schema(); + this.f4530 = readerSchema.getField("F453").schema(); + this.f4540 = readerSchema.getField("F454").schema(); + this.f4550 = readerSchema.getField("F455").schema(); + this.f4560 = readerSchema.getField("F456").schema(); + this.f4570 = readerSchema.getField("F457").schema(); + this.f4580 = readerSchema.getField("F458").schema(); + this.f4590 = readerSchema.getField("F459").schema(); + this.f4600 = readerSchema.getField("F460").schema(); + this.f4610 = readerSchema.getField("F461").schema(); + this.f4620 = readerSchema.getField("F462").schema(); + this.f4630 = readerSchema.getField("F463").schema(); + this.f4640 = readerSchema.getField("F464").schema(); + this.f4650 = readerSchema.getField("F465").schema(); + this.f4660 = readerSchema.getField("F466").schema(); + this.f4670 = readerSchema.getField("F467").schema(); + this.f4680 = readerSchema.getField("F468").schema(); + this.f4690 = readerSchema.getField("F469").schema(); + this.f4700 = readerSchema.getField("F470").schema(); + this.f4710 = readerSchema.getField("F471").schema(); + this.f4720 = readerSchema.getField("F472").schema(); + this.f4730 = readerSchema.getField("F473").schema(); + this.f4740 = readerSchema.getField("F474").schema(); + this.f4750 = readerSchema.getField("F475").schema(); + this.f4760 = readerSchema.getField("F476").schema(); + this.f4770 = readerSchema.getField("F477").schema(); + this.f4780 = readerSchema.getField("F478").schema(); + this.f4790 = readerSchema.getField("F479").schema(); + this.f4800 = readerSchema.getField("F480").schema(); + this.f4810 = readerSchema.getField("F481").schema(); + this.f4820 = readerSchema.getField("F482").schema(); + this.f4830 = readerSchema.getField("F483").schema(); + this.f4840 = readerSchema.getField("F484").schema(); + this.f4850 = readerSchema.getField("F485").schema(); + this.f4860 = readerSchema.getField("F486").schema(); + this.f4870 = readerSchema.getField("F487").schema(); + this.f4880 = readerSchema.getField("F488").schema(); + this.f4890 = readerSchema.getField("F489").schema(); + this.f4900 = readerSchema.getField("F490").schema(); + this.f4910 = readerSchema.getField("F491").schema(); + this.f4920 = readerSchema.getField("F492").schema(); + this.f4930 = readerSchema.getField("F493").schema(); + this.f4940 = readerSchema.getField("F494").schema(); + this.f4950 = readerSchema.getField("F495").schema(); + this.f4960 = readerSchema.getField("F496").schema(); + this.f4970 = readerSchema.getField("F497").schema(); + this.f4980 = readerSchema.getField("F498").schema(); + this.f4990 = readerSchema.getField("F499").schema(); + this.f5000 = readerSchema.getField("F500").schema(); + this.f5010 = readerSchema.getField("F501").schema(); + this.f5020 = readerSchema.getField("F502").schema(); + this.f5030 = readerSchema.getField("F503").schema(); + this.f5040 = readerSchema.getField("F504").schema(); + this.f5050 = readerSchema.getField("F505").schema(); + this.f5060 = readerSchema.getField("F506").schema(); + this.f5070 = readerSchema.getField("F507").schema(); + this.f5080 = readerSchema.getField("F508").schema(); + this.f5090 = readerSchema.getField("F509").schema(); + this.f5100 = readerSchema.getField("F510").schema(); + this.f5110 = readerSchema.getField("F511").schema(); + this.f5120 = readerSchema.getField("F512").schema(); + this.f5130 = readerSchema.getField("F513").schema(); + this.f5140 = readerSchema.getField("F514").schema(); + this.f5150 = readerSchema.getField("F515").schema(); + this.f5160 = readerSchema.getField("F516").schema(); + this.f5170 = readerSchema.getField("F517").schema(); + this.f5180 = readerSchema.getField("F518").schema(); + this.f5190 = readerSchema.getField("F519").schema(); + this.f5200 = readerSchema.getField("F520").schema(); + this.f5210 = readerSchema.getField("F521").schema(); + this.f5220 = readerSchema.getField("F522").schema(); + this.f5230 = readerSchema.getField("F523").schema(); + this.f5240 = readerSchema.getField("F524").schema(); + this.f5250 = readerSchema.getField("F525").schema(); + this.f5260 = readerSchema.getField("F526").schema(); + this.f5270 = readerSchema.getField("F527").schema(); + this.f5280 = readerSchema.getField("F528").schema(); + this.f5290 = readerSchema.getField("F529").schema(); + this.f5300 = readerSchema.getField("F530").schema(); + this.f5310 = readerSchema.getField("F531").schema(); + this.f5320 = readerSchema.getField("F532").schema(); + this.f5330 = readerSchema.getField("F533").schema(); + this.f5340 = readerSchema.getField("F534").schema(); + this.f5350 = readerSchema.getField("F535").schema(); + this.f5360 = readerSchema.getField("F536").schema(); + this.f5370 = readerSchema.getField("F537").schema(); + this.f5380 = readerSchema.getField("F538").schema(); + this.f5390 = readerSchema.getField("F539").schema(); + this.f5400 = readerSchema.getField("F540").schema(); + this.f5410 = readerSchema.getField("F541").schema(); + this.f5420 = readerSchema.getField("F542").schema(); + this.f5430 = readerSchema.getField("F543").schema(); + this.f5440 = readerSchema.getField("F544").schema(); + this.f5450 = readerSchema.getField("F545").schema(); + this.f5460 = readerSchema.getField("F546").schema(); + this.f5470 = readerSchema.getField("F547").schema(); + this.f5480 = readerSchema.getField("F548").schema(); + this.f5490 = readerSchema.getField("F549").schema(); + this.f5500 = readerSchema.getField("F550").schema(); + this.f5510 = readerSchema.getField("F551").schema(); + this.f5520 = readerSchema.getField("F552").schema(); + this.f5530 = readerSchema.getField("F553").schema(); + this.f5540 = readerSchema.getField("F554").schema(); + this.f5550 = readerSchema.getField("F555").schema(); + this.f5560 = readerSchema.getField("F556").schema(); + this.f5570 = readerSchema.getField("F557").schema(); + this.f5580 = readerSchema.getField("F558").schema(); + this.f5590 = readerSchema.getField("F559").schema(); + this.f5600 = readerSchema.getField("F560").schema(); + this.f5610 = readerSchema.getField("F561").schema(); + this.f5620 = readerSchema.getField("F562").schema(); + this.f5630 = readerSchema.getField("F563").schema(); + this.f5640 = readerSchema.getField("F564").schema(); + this.f5650 = readerSchema.getField("F565").schema(); + this.f5660 = readerSchema.getField("F566").schema(); + this.f5670 = readerSchema.getField("F567").schema(); + this.f5680 = readerSchema.getField("F568").schema(); + this.f5690 = readerSchema.getField("F569").schema(); + this.f5700 = readerSchema.getField("F570").schema(); + this.f5710 = readerSchema.getField("F571").schema(); + this.f5720 = readerSchema.getField("F572").schema(); + this.f5730 = readerSchema.getField("F573").schema(); + this.f5740 = readerSchema.getField("F574").schema(); + this.f5750 = readerSchema.getField("F575").schema(); + this.f5760 = readerSchema.getField("F576").schema(); + this.f5770 = readerSchema.getField("F577").schema(); + this.f5780 = readerSchema.getField("F578").schema(); + this.f5790 = readerSchema.getField("F579").schema(); + this.f5800 = readerSchema.getField("F580").schema(); + this.f5810 = readerSchema.getField("F581").schema(); + this.f5820 = readerSchema.getField("F582").schema(); + this.f5830 = readerSchema.getField("F583").schema(); + this.f5840 = readerSchema.getField("F584").schema(); + this.f5850 = readerSchema.getField("F585").schema(); + this.f5860 = readerSchema.getField("F586").schema(); + this.f5870 = readerSchema.getField("F587").schema(); + this.f5880 = readerSchema.getField("F588").schema(); + this.f5890 = readerSchema.getField("F589").schema(); + this.f5900 = readerSchema.getField("F590").schema(); + this.f5910 = readerSchema.getField("F591").schema(); + this.f5920 = readerSchema.getField("F592").schema(); + this.f5930 = readerSchema.getField("F593").schema(); + this.f5940 = readerSchema.getField("F594").schema(); + this.f5950 = readerSchema.getField("F595").schema(); + this.f5960 = readerSchema.getField("F596").schema(); + this.f5970 = readerSchema.getField("F597").schema(); + this.f5980 = readerSchema.getField("F598").schema(); + this.f5990 = readerSchema.getField("F599").schema(); + this.f6000 = readerSchema.getField("F600").schema(); + this.f6010 = readerSchema.getField("F601").schema(); + this.f6020 = readerSchema.getField("F602").schema(); + this.f6030 = readerSchema.getField("F603").schema(); + this.f6040 = readerSchema.getField("F604").schema(); + this.f6050 = readerSchema.getField("F605").schema(); + this.f6060 = readerSchema.getField("F606").schema(); + this.f6070 = readerSchema.getField("F607").schema(); + this.f6080 = readerSchema.getField("F608").schema(); + this.f6090 = readerSchema.getField("F609").schema(); + this.f6100 = readerSchema.getField("F610").schema(); + this.f6110 = readerSchema.getField("F611").schema(); + this.f6120 = readerSchema.getField("F612").schema(); + this.f6130 = readerSchema.getField("F613").schema(); + this.f6140 = readerSchema.getField("F614").schema(); + this.f6150 = readerSchema.getField("F615").schema(); + this.f6160 = readerSchema.getField("F616").schema(); + this.f6170 = readerSchema.getField("F617").schema(); + this.f6180 = readerSchema.getField("F618").schema(); + this.f6190 = readerSchema.getField("F619").schema(); + this.f6200 = readerSchema.getField("F620").schema(); + this.f6210 = readerSchema.getField("F621").schema(); + this.f6220 = readerSchema.getField("F622").schema(); + this.f6230 = readerSchema.getField("F623").schema(); + this.f6240 = readerSchema.getField("F624").schema(); + this.f6250 = readerSchema.getField("F625").schema(); + this.f6260 = readerSchema.getField("F626").schema(); + this.f6270 = readerSchema.getField("F627").schema(); + this.f6280 = readerSchema.getField("F628").schema(); + this.f6290 = readerSchema.getField("F629").schema(); + this.f6300 = readerSchema.getField("F630").schema(); + this.f6310 = readerSchema.getField("F631").schema(); + this.f6320 = readerSchema.getField("F632").schema(); + this.f6330 = readerSchema.getField("F633").schema(); + this.f6340 = readerSchema.getField("F634").schema(); + this.f6350 = readerSchema.getField("F635").schema(); + this.f6360 = readerSchema.getField("F636").schema(); + this.f6370 = readerSchema.getField("F637").schema(); + this.f6380 = readerSchema.getField("F638").schema(); + this.f6390 = readerSchema.getField("F639").schema(); + this.f6400 = readerSchema.getField("F640").schema(); + this.f6410 = readerSchema.getField("F641").schema(); + this.f6420 = readerSchema.getField("F642").schema(); + this.f6430 = readerSchema.getField("F643").schema(); + this.f6440 = readerSchema.getField("F644").schema(); + this.f6450 = readerSchema.getField("F645").schema(); + this.f6460 = readerSchema.getField("F646").schema(); + this.f6470 = readerSchema.getField("F647").schema(); + this.f6480 = readerSchema.getField("F648").schema(); + this.f6490 = readerSchema.getField("F649").schema(); + this.f6500 = readerSchema.getField("F650").schema(); + this.f6510 = readerSchema.getField("F651").schema(); + this.f6520 = readerSchema.getField("F652").schema(); + this.f6530 = readerSchema.getField("F653").schema(); + this.f6540 = readerSchema.getField("F654").schema(); + this.f6550 = readerSchema.getField("F655").schema(); + this.f6560 = readerSchema.getField("F656").schema(); + this.f6570 = readerSchema.getField("F657").schema(); + this.f6580 = readerSchema.getField("F658").schema(); + this.f6590 = readerSchema.getField("F659").schema(); + this.f6600 = readerSchema.getField("F660").schema(); + this.f6610 = readerSchema.getField("F661").schema(); + this.f6620 = readerSchema.getField("F662").schema(); + this.f6630 = readerSchema.getField("F663").schema(); + this.f6640 = readerSchema.getField("F664").schema(); + this.f6650 = readerSchema.getField("F665").schema(); + this.f6660 = readerSchema.getField("F666").schema(); + this.f6670 = readerSchema.getField("F667").schema(); + this.f6680 = readerSchema.getField("F668").schema(); + this.f6690 = readerSchema.getField("F669").schema(); + this.f6700 = readerSchema.getField("F670").schema(); + this.f6710 = readerSchema.getField("F671").schema(); + this.f6720 = readerSchema.getField("F672").schema(); + this.f6730 = readerSchema.getField("F673").schema(); + this.f6740 = readerSchema.getField("F674").schema(); + this.f6750 = readerSchema.getField("F675").schema(); + this.f6760 = readerSchema.getField("F676").schema(); + this.f6770 = readerSchema.getField("F677").schema(); + this.f6780 = readerSchema.getField("F678").schema(); + this.f6790 = readerSchema.getField("F679").schema(); + this.f6800 = readerSchema.getField("F680").schema(); + this.f6810 = readerSchema.getField("F681").schema(); + this.f6820 = readerSchema.getField("F682").schema(); + this.f6830 = readerSchema.getField("F683").schema(); + this.f6840 = readerSchema.getField("F684").schema(); + this.f6850 = readerSchema.getField("F685").schema(); + this.f6860 = readerSchema.getField("F686").schema(); + this.f6870 = readerSchema.getField("F687").schema(); + this.f6880 = readerSchema.getField("F688").schema(); + this.f6890 = readerSchema.getField("F689").schema(); + this.f6900 = readerSchema.getField("F690").schema(); + this.f6910 = readerSchema.getField("F691").schema(); + this.f6920 = readerSchema.getField("F692").schema(); + this.f6930 = readerSchema.getField("F693").schema(); + this.f6940 = readerSchema.getField("F694").schema(); + this.f6950 = readerSchema.getField("F695").schema(); + this.f6960 = readerSchema.getField("F696").schema(); + this.f6970 = readerSchema.getField("F697").schema(); + this.f6980 = readerSchema.getField("F698").schema(); + this.f6990 = readerSchema.getField("F699").schema(); + this.f7000 = readerSchema.getField("F700").schema(); + this.f7010 = readerSchema.getField("F701").schema(); + this.f7020 = readerSchema.getField("F702").schema(); + this.f7030 = readerSchema.getField("F703").schema(); + this.f7040 = readerSchema.getField("F704").schema(); + this.f7050 = readerSchema.getField("F705").schema(); + this.f7060 = readerSchema.getField("F706").schema(); + this.f7070 = readerSchema.getField("F707").schema(); + this.f7080 = readerSchema.getField("F708").schema(); + this.f7090 = readerSchema.getField("F709").schema(); + this.f7100 = readerSchema.getField("F710").schema(); + this.f7110 = readerSchema.getField("F711").schema(); + this.f7120 = readerSchema.getField("F712").schema(); + this.f7130 = readerSchema.getField("F713").schema(); + this.f7140 = readerSchema.getField("F714").schema(); + this.f7150 = readerSchema.getField("F715").schema(); + this.f7160 = readerSchema.getField("F716").schema(); + this.f7170 = readerSchema.getField("F717").schema(); + this.f7180 = readerSchema.getField("F718").schema(); + this.f7190 = readerSchema.getField("F719").schema(); + this.f7200 = readerSchema.getField("F720").schema(); + this.f7210 = readerSchema.getField("F721").schema(); + this.f7220 = readerSchema.getField("F722").schema(); + this.f7230 = readerSchema.getField("F723").schema(); + this.f7240 = readerSchema.getField("F724").schema(); + this.f7250 = readerSchema.getField("F725").schema(); + this.f7260 = readerSchema.getField("F726").schema(); + this.f7270 = readerSchema.getField("F727").schema(); + this.f7280 = readerSchema.getField("F728").schema(); + this.f7290 = readerSchema.getField("F729").schema(); + this.f7300 = readerSchema.getField("F730").schema(); + this.f7310 = readerSchema.getField("F731").schema(); + this.f7320 = readerSchema.getField("F732").schema(); + this.f7330 = readerSchema.getField("F733").schema(); + this.f7340 = readerSchema.getField("F734").schema(); + this.f7350 = readerSchema.getField("F735").schema(); + this.f7360 = readerSchema.getField("F736").schema(); + this.f7370 = readerSchema.getField("F737").schema(); + this.f7380 = readerSchema.getField("F738").schema(); + this.f7390 = readerSchema.getField("F739").schema(); + this.f7400 = readerSchema.getField("F740").schema(); + this.f7410 = readerSchema.getField("F741").schema(); + this.f7420 = readerSchema.getField("F742").schema(); + this.f7430 = readerSchema.getField("F743").schema(); + this.f7440 = readerSchema.getField("F744").schema(); + this.f7450 = readerSchema.getField("F745").schema(); + this.f7460 = readerSchema.getField("F746").schema(); + this.f7470 = readerSchema.getField("F747").schema(); + this.f7480 = readerSchema.getField("F748").schema(); + this.f7490 = readerSchema.getField("F749").schema(); + this.f7500 = readerSchema.getField("F750").schema(); + this.f7510 = readerSchema.getField("F751").schema(); + this.f7520 = readerSchema.getField("F752").schema(); + this.f7530 = readerSchema.getField("F753").schema(); + this.f7540 = readerSchema.getField("F754").schema(); + this.f7550 = readerSchema.getField("F755").schema(); + this.f7560 = readerSchema.getField("F756").schema(); + this.f7570 = readerSchema.getField("F757").schema(); + this.f7580 = readerSchema.getField("F758").schema(); + this.f7590 = readerSchema.getField("F759").schema(); + this.f7600 = readerSchema.getField("F760").schema(); + this.f7610 = readerSchema.getField("F761").schema(); + this.f7620 = readerSchema.getField("F762").schema(); + this.f7630 = readerSchema.getField("F763").schema(); + this.f7640 = readerSchema.getField("F764").schema(); + this.f7650 = readerSchema.getField("F765").schema(); + this.f7660 = readerSchema.getField("F766").schema(); + this.f7670 = readerSchema.getField("F767").schema(); + this.f7680 = readerSchema.getField("F768").schema(); + this.f7690 = readerSchema.getField("F769").schema(); + this.f7700 = readerSchema.getField("F770").schema(); + this.f7710 = readerSchema.getField("F771").schema(); + this.f7720 = readerSchema.getField("F772").schema(); + this.f7730 = readerSchema.getField("F773").schema(); + this.f7740 = readerSchema.getField("F774").schema(); + this.f7750 = readerSchema.getField("F775").schema(); + this.f7760 = readerSchema.getField("F776").schema(); + this.f7770 = readerSchema.getField("F777").schema(); + this.f7780 = readerSchema.getField("F778").schema(); + this.f7790 = readerSchema.getField("F779").schema(); + this.f7800 = readerSchema.getField("F780").schema(); + this.f7810 = readerSchema.getField("F781").schema(); + this.f7820 = readerSchema.getField("F782").schema(); + this.f7830 = readerSchema.getField("F783").schema(); + this.f7840 = readerSchema.getField("F784").schema(); + this.f7850 = readerSchema.getField("F785").schema(); + this.f7860 = readerSchema.getField("F786").schema(); + this.f7870 = readerSchema.getField("F787").schema(); + this.f7880 = readerSchema.getField("F788").schema(); + this.f7890 = readerSchema.getField("F789").schema(); + this.f7900 = readerSchema.getField("F790").schema(); + this.f7910 = readerSchema.getField("F791").schema(); + this.f7920 = readerSchema.getField("F792").schema(); + this.f7930 = readerSchema.getField("F793").schema(); + this.f7940 = readerSchema.getField("F794").schema(); + this.f7950 = readerSchema.getField("F795").schema(); + this.f7960 = readerSchema.getField("F796").schema(); + this.f7970 = readerSchema.getField("F797").schema(); + this.f7980 = readerSchema.getField("F798").schema(); + this.f7990 = readerSchema.getField("F799").schema(); + this.f8000 = readerSchema.getField("F800").schema(); + this.f8010 = readerSchema.getField("F801").schema(); + this.f8020 = readerSchema.getField("F802").schema(); + this.f8030 = readerSchema.getField("F803").schema(); + this.f8040 = readerSchema.getField("F804").schema(); + this.f8050 = readerSchema.getField("F805").schema(); + this.f8060 = readerSchema.getField("F806").schema(); + this.f8070 = readerSchema.getField("F807").schema(); + this.f8080 = readerSchema.getField("F808").schema(); + this.f8090 = readerSchema.getField("F809").schema(); + this.f8100 = readerSchema.getField("F810").schema(); + this.f8110 = readerSchema.getField("F811").schema(); + this.f8120 = readerSchema.getField("F812").schema(); + this.f8130 = readerSchema.getField("F813").schema(); + this.f8140 = readerSchema.getField("F814").schema(); + this.f8150 = readerSchema.getField("F815").schema(); + this.f8160 = readerSchema.getField("F816").schema(); + this.f8170 = readerSchema.getField("F817").schema(); + this.f8180 = readerSchema.getField("F818").schema(); + this.f8190 = readerSchema.getField("F819").schema(); + this.f8200 = readerSchema.getField("F820").schema(); + this.f8210 = readerSchema.getField("F821").schema(); + this.f8220 = readerSchema.getField("F822").schema(); + this.f8230 = readerSchema.getField("F823").schema(); + this.f8240 = readerSchema.getField("F824").schema(); + this.f8250 = readerSchema.getField("F825").schema(); + this.f8260 = readerSchema.getField("F826").schema(); + this.f8270 = readerSchema.getField("F827").schema(); + this.f8280 = readerSchema.getField("F828").schema(); + this.f8290 = readerSchema.getField("F829").schema(); + this.f8300 = readerSchema.getField("F830").schema(); + this.f8310 = readerSchema.getField("F831").schema(); + this.f8320 = readerSchema.getField("F832").schema(); + this.f8330 = readerSchema.getField("F833").schema(); + this.f8340 = readerSchema.getField("F834").schema(); + this.f8350 = readerSchema.getField("F835").schema(); + this.f8360 = readerSchema.getField("F836").schema(); + this.f8370 = readerSchema.getField("F837").schema(); + this.f8380 = readerSchema.getField("F838").schema(); + this.f8390 = readerSchema.getField("F839").schema(); + this.f8400 = readerSchema.getField("F840").schema(); + this.f8410 = readerSchema.getField("F841").schema(); + this.f8420 = readerSchema.getField("F842").schema(); + this.f8430 = readerSchema.getField("F843").schema(); + this.f8440 = readerSchema.getField("F844").schema(); + this.f8450 = readerSchema.getField("F845").schema(); + this.f8460 = readerSchema.getField("F846").schema(); + this.f8470 = readerSchema.getField("F847").schema(); + this.f8480 = readerSchema.getField("F848").schema(); + this.f8490 = readerSchema.getField("F849").schema(); + this.f8500 = readerSchema.getField("F850").schema(); + this.f8510 = readerSchema.getField("F851").schema(); + this.f8520 = readerSchema.getField("F852").schema(); + this.f8530 = readerSchema.getField("F853").schema(); + this.f8540 = readerSchema.getField("F854").schema(); + this.f8550 = readerSchema.getField("F855").schema(); + this.f8560 = readerSchema.getField("F856").schema(); + this.f8570 = readerSchema.getField("F857").schema(); + this.f8580 = readerSchema.getField("F858").schema(); + this.f8590 = readerSchema.getField("F859").schema(); + this.f8600 = readerSchema.getField("F860").schema(); + this.f8610 = readerSchema.getField("F861").schema(); + this.f8620 = readerSchema.getField("F862").schema(); + this.f8630 = readerSchema.getField("F863").schema(); + this.f8640 = readerSchema.getField("F864").schema(); + this.f8650 = readerSchema.getField("F865").schema(); + this.f8660 = readerSchema.getField("F866").schema(); + this.f8670 = readerSchema.getField("F867").schema(); + this.f8680 = readerSchema.getField("F868").schema(); + this.f8690 = readerSchema.getField("F869").schema(); + this.f8700 = readerSchema.getField("F870").schema(); + this.f8710 = readerSchema.getField("F871").schema(); + this.f8720 = readerSchema.getField("F872").schema(); + this.f8730 = readerSchema.getField("F873").schema(); + this.f8740 = readerSchema.getField("F874").schema(); + this.f8750 = readerSchema.getField("F875").schema(); + this.f8760 = readerSchema.getField("F876").schema(); + this.f8770 = readerSchema.getField("F877").schema(); + this.f8780 = readerSchema.getField("F878").schema(); + this.f8790 = readerSchema.getField("F879").schema(); + this.f8800 = readerSchema.getField("F880").schema(); + this.f8810 = readerSchema.getField("F881").schema(); + this.f8820 = readerSchema.getField("F882").schema(); + this.f8830 = readerSchema.getField("F883").schema(); + this.f8840 = readerSchema.getField("F884").schema(); + this.f8850 = readerSchema.getField("F885").schema(); + this.f8860 = readerSchema.getField("F886").schema(); + this.f8870 = readerSchema.getField("F887").schema(); + this.f8880 = readerSchema.getField("F888").schema(); + this.f8890 = readerSchema.getField("F889").schema(); + this.f8900 = readerSchema.getField("F890").schema(); + this.f8910 = readerSchema.getField("F891").schema(); + this.f8920 = readerSchema.getField("F892").schema(); + this.f8930 = readerSchema.getField("F893").schema(); + this.f8940 = readerSchema.getField("F894").schema(); + this.f8950 = readerSchema.getField("F895").schema(); + this.f8960 = readerSchema.getField("F896").schema(); + this.f8970 = readerSchema.getField("F897").schema(); + this.f8980 = readerSchema.getField("F898").schema(); + this.f8990 = readerSchema.getField("F899").schema(); + this.f9000 = readerSchema.getField("F900").schema(); + this.f9010 = readerSchema.getField("F901").schema(); + this.f9020 = readerSchema.getField("F902").schema(); + this.f9030 = readerSchema.getField("F903").schema(); + this.f9040 = readerSchema.getField("F904").schema(); + this.f9050 = readerSchema.getField("F905").schema(); + this.f9060 = readerSchema.getField("F906").schema(); + this.f9070 = readerSchema.getField("F907").schema(); + this.f9080 = readerSchema.getField("F908").schema(); + this.f9090 = readerSchema.getField("F909").schema(); + this.f9100 = readerSchema.getField("F910").schema(); + this.f9110 = readerSchema.getField("F911").schema(); + this.f9120 = readerSchema.getField("F912").schema(); + this.f9130 = readerSchema.getField("F913").schema(); + this.f9140 = readerSchema.getField("F914").schema(); + this.f9150 = readerSchema.getField("F915").schema(); + this.f9160 = readerSchema.getField("F916").schema(); + this.f9170 = readerSchema.getField("F917").schema(); + this.f9180 = readerSchema.getField("F918").schema(); + this.f9190 = readerSchema.getField("F919").schema(); + this.f9200 = readerSchema.getField("F920").schema(); + this.f9210 = readerSchema.getField("F921").schema(); + this.f9220 = readerSchema.getField("F922").schema(); + this.f9230 = readerSchema.getField("F923").schema(); + this.f9240 = readerSchema.getField("F924").schema(); + this.f9250 = readerSchema.getField("F925").schema(); + this.f9260 = readerSchema.getField("F926").schema(); + this.f9270 = readerSchema.getField("F927").schema(); + this.f9280 = readerSchema.getField("F928").schema(); + this.f9290 = readerSchema.getField("F929").schema(); + this.f9300 = readerSchema.getField("F930").schema(); + this.f9310 = readerSchema.getField("F931").schema(); + this.f9320 = readerSchema.getField("F932").schema(); + this.f9330 = readerSchema.getField("F933").schema(); + this.f9340 = readerSchema.getField("F934").schema(); + this.f9350 = readerSchema.getField("F935").schema(); + this.f9360 = readerSchema.getField("F936").schema(); + this.f9370 = readerSchema.getField("F937").schema(); + this.f9380 = readerSchema.getField("F938").schema(); + this.f9390 = readerSchema.getField("F939").schema(); + this.f9400 = readerSchema.getField("F940").schema(); + this.f9410 = readerSchema.getField("F941").schema(); + this.f9420 = readerSchema.getField("F942").schema(); + this.f9430 = readerSchema.getField("F943").schema(); + this.f9440 = readerSchema.getField("F944").schema(); + this.f9450 = readerSchema.getField("F945").schema(); + this.f9460 = readerSchema.getField("F946").schema(); + this.f9470 = readerSchema.getField("F947").schema(); + this.f9480 = readerSchema.getField("F948").schema(); + this.f9490 = readerSchema.getField("F949").schema(); + this.f9500 = readerSchema.getField("F950").schema(); + this.f9510 = readerSchema.getField("F951").schema(); + this.f9520 = readerSchema.getField("F952").schema(); + this.f9530 = readerSchema.getField("F953").schema(); + this.f9540 = readerSchema.getField("F954").schema(); + this.f9550 = readerSchema.getField("F955").schema(); + this.f9560 = readerSchema.getField("F956").schema(); + this.f9570 = readerSchema.getField("F957").schema(); + this.f9580 = readerSchema.getField("F958").schema(); + this.f9590 = readerSchema.getField("F959").schema(); + this.f9600 = readerSchema.getField("F960").schema(); + this.f9610 = readerSchema.getField("F961").schema(); + this.f9620 = readerSchema.getField("F962").schema(); + this.f9630 = readerSchema.getField("F963").schema(); + this.f9640 = readerSchema.getField("F964").schema(); + this.f9650 = readerSchema.getField("F965").schema(); + this.f9660 = readerSchema.getField("F966").schema(); + this.f9670 = readerSchema.getField("F967").schema(); + this.f9680 = readerSchema.getField("F968").schema(); + this.f9690 = readerSchema.getField("F969").schema(); + this.f9700 = readerSchema.getField("F970").schema(); + this.f9710 = readerSchema.getField("F971").schema(); + this.f9720 = readerSchema.getField("F972").schema(); + this.f9730 = readerSchema.getField("F973").schema(); + this.f9740 = readerSchema.getField("F974").schema(); + this.f9750 = readerSchema.getField("F975").schema(); + this.f9760 = readerSchema.getField("F976").schema(); + this.f9770 = readerSchema.getField("F977").schema(); + this.f9780 = readerSchema.getField("F978").schema(); + this.f9790 = readerSchema.getField("F979").schema(); + this.f9800 = readerSchema.getField("F980").schema(); + this.f9810 = readerSchema.getField("F981").schema(); + this.f9820 = readerSchema.getField("F982").schema(); + this.f9830 = readerSchema.getField("F983").schema(); + this.f9840 = readerSchema.getField("F984").schema(); + this.f9850 = readerSchema.getField("F985").schema(); + this.f9860 = readerSchema.getField("F986").schema(); + this.f9870 = readerSchema.getField("F987").schema(); + this.f9880 = readerSchema.getField("F988").schema(); + this.f9890 = readerSchema.getField("F989").schema(); + this.f9900 = readerSchema.getField("F990").schema(); + this.f9910 = readerSchema.getField("F991").schema(); + this.f9920 = readerSchema.getField("F992").schema(); + this.f9930 = readerSchema.getField("F993").schema(); + this.f9940 = readerSchema.getField("F994").schema(); + this.f9950 = readerSchema.getField("F995").schema(); + this.f9960 = readerSchema.getField("F996").schema(); + this.f9970 = readerSchema.getField("F997").schema(); + this.f9980 = readerSchema.getField("F998").schema(); + this.f9990 = readerSchema.getField("F999").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'F0': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(1, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'F1': "+ unionIndex1)); + } + } + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(2, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence2; + Object oldString2 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(2); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(2, charSequence2); + } else { + throw new RuntimeException(("Illegal union index for 'F2': "+ unionIndex2)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(3, null); + } else { + if (unionIndex3 == 1) { + Utf8 charSequence3; + Object oldString3 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(3); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(3, charSequence3); + } else { + throw new RuntimeException(("Illegal union index for 'F3': "+ unionIndex3)); + } + } + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(4, null); + } else { + if (unionIndex4 == 1) { + Utf8 charSequence4; + Object oldString4 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(4); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(4, charSequence4); + } else { + throw new RuntimeException(("Illegal union index for 'F4': "+ unionIndex4)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(5, null); + } else { + if (unionIndex5 == 1) { + Utf8 charSequence5; + Object oldString5 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(5); + if (oldString5 instanceof Utf8) { + charSequence5 = (decoder).readString(((Utf8) oldString5)); + } else { + charSequence5 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(5, charSequence5); + } else { + throw new RuntimeException(("Illegal union index for 'F5': "+ unionIndex5)); + } + } + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(6, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence6; + Object oldString6 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(6); + if (oldString6 instanceof Utf8) { + charSequence6 = (decoder).readString(((Utf8) oldString6)); + } else { + charSequence6 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(6, charSequence6); + } else { + throw new RuntimeException(("Illegal union index for 'F6': "+ unionIndex6)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(7, null); + } else { + if (unionIndex7 == 1) { + Utf8 charSequence7; + Object oldString7 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(7); + if (oldString7 instanceof Utf8) { + charSequence7 = (decoder).readString(((Utf8) oldString7)); + } else { + charSequence7 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(7, charSequence7); + } else { + throw new RuntimeException(("Illegal union index for 'F7': "+ unionIndex7)); + } + } + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(8, null); + } else { + if (unionIndex8 == 1) { + Utf8 charSequence8; + Object oldString8 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(8); + if (oldString8 instanceof Utf8) { + charSequence8 = (decoder).readString(((Utf8) oldString8)); + } else { + charSequence8 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(8, charSequence8); + } else { + throw new RuntimeException(("Illegal union index for 'F8': "+ unionIndex8)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex9 = (decoder.readIndex()); + if (unionIndex9 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(9, null); + } else { + if (unionIndex9 == 1) { + Utf8 charSequence9; + Object oldString9 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(9); + if (oldString9 instanceof Utf8) { + charSequence9 = (decoder).readString(((Utf8) oldString9)); + } else { + charSequence9 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(9, charSequence9); + } else { + throw new RuntimeException(("Illegal union index for 'F9': "+ unionIndex9)); + } + } + int unionIndex10 = (decoder.readIndex()); + if (unionIndex10 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(10, null); + } else { + if (unionIndex10 == 1) { + Utf8 charSequence10; + Object oldString10 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(10); + if (oldString10 instanceof Utf8) { + charSequence10 = (decoder).readString(((Utf8) oldString10)); + } else { + charSequence10 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(10, charSequence10); + } else { + throw new RuntimeException(("Illegal union index for 'F10': "+ unionIndex10)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex11 = (decoder.readIndex()); + if (unionIndex11 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(11, null); + } else { + if (unionIndex11 == 1) { + Utf8 charSequence11; + Object oldString11 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(11); + if (oldString11 instanceof Utf8) { + charSequence11 = (decoder).readString(((Utf8) oldString11)); + } else { + charSequence11 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(11, charSequence11); + } else { + throw new RuntimeException(("Illegal union index for 'F11': "+ unionIndex11)); + } + } + int unionIndex12 = (decoder.readIndex()); + if (unionIndex12 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(12, null); + } else { + if (unionIndex12 == 1) { + Utf8 charSequence12; + Object oldString12 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(12); + if (oldString12 instanceof Utf8) { + charSequence12 = (decoder).readString(((Utf8) oldString12)); + } else { + charSequence12 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(12, charSequence12); + } else { + throw new RuntimeException(("Illegal union index for 'F12': "+ unionIndex12)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex13 = (decoder.readIndex()); + if (unionIndex13 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(13, null); + } else { + if (unionIndex13 == 1) { + Utf8 charSequence13; + Object oldString13 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(13); + if (oldString13 instanceof Utf8) { + charSequence13 = (decoder).readString(((Utf8) oldString13)); + } else { + charSequence13 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(13, charSequence13); + } else { + throw new RuntimeException(("Illegal union index for 'F13': "+ unionIndex13)); + } + } + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(14, null); + } else { + if (unionIndex14 == 1) { + Utf8 charSequence14; + Object oldString14 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(14); + if (oldString14 instanceof Utf8) { + charSequence14 = (decoder).readString(((Utf8) oldString14)); + } else { + charSequence14 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(14, charSequence14); + } else { + throw new RuntimeException(("Illegal union index for 'F14': "+ unionIndex14)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(15, null); + } else { + if (unionIndex15 == 1) { + Utf8 charSequence15; + Object oldString15 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(15); + if (oldString15 instanceof Utf8) { + charSequence15 = (decoder).readString(((Utf8) oldString15)); + } else { + charSequence15 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(15, charSequence15); + } else { + throw new RuntimeException(("Illegal union index for 'F15': "+ unionIndex15)); + } + } + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(16, null); + } else { + if (unionIndex16 == 1) { + Utf8 charSequence16; + Object oldString16 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(16); + if (oldString16 instanceof Utf8) { + charSequence16 = (decoder).readString(((Utf8) oldString16)); + } else { + charSequence16 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(16, charSequence16); + } else { + throw new RuntimeException(("Illegal union index for 'F16': "+ unionIndex16)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex17 = (decoder.readIndex()); + if (unionIndex17 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(17, null); + } else { + if (unionIndex17 == 1) { + Utf8 charSequence17; + Object oldString17 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(17); + if (oldString17 instanceof Utf8) { + charSequence17 = (decoder).readString(((Utf8) oldString17)); + } else { + charSequence17 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(17, charSequence17); + } else { + throw new RuntimeException(("Illegal union index for 'F17': "+ unionIndex17)); + } + } + int unionIndex18 = (decoder.readIndex()); + if (unionIndex18 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(18, null); + } else { + if (unionIndex18 == 1) { + Utf8 charSequence18; + Object oldString18 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(18); + if (oldString18 instanceof Utf8) { + charSequence18 = (decoder).readString(((Utf8) oldString18)); + } else { + charSequence18 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(18, charSequence18); + } else { + throw new RuntimeException(("Illegal union index for 'F18': "+ unionIndex18)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex19 = (decoder.readIndex()); + if (unionIndex19 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(19, null); + } else { + if (unionIndex19 == 1) { + Utf8 charSequence19; + Object oldString19 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(19); + if (oldString19 instanceof Utf8) { + charSequence19 = (decoder).readString(((Utf8) oldString19)); + } else { + charSequence19 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(19, charSequence19); + } else { + throw new RuntimeException(("Illegal union index for 'F19': "+ unionIndex19)); + } + } + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(20, null); + } else { + if (unionIndex20 == 1) { + Utf8 charSequence20; + Object oldString20 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(20); + if (oldString20 instanceof Utf8) { + charSequence20 = (decoder).readString(((Utf8) oldString20)); + } else { + charSequence20 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(20, charSequence20); + } else { + throw new RuntimeException(("Illegal union index for 'F20': "+ unionIndex20)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(21, null); + } else { + if (unionIndex21 == 1) { + Utf8 charSequence21; + Object oldString21 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(21); + if (oldString21 instanceof Utf8) { + charSequence21 = (decoder).readString(((Utf8) oldString21)); + } else { + charSequence21 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(21, charSequence21); + } else { + throw new RuntimeException(("Illegal union index for 'F21': "+ unionIndex21)); + } + } + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(22, null); + } else { + if (unionIndex22 == 1) { + Utf8 charSequence22; + Object oldString22 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(22); + if (oldString22 instanceof Utf8) { + charSequence22 = (decoder).readString(((Utf8) oldString22)); + } else { + charSequence22 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(22, charSequence22); + } else { + throw new RuntimeException(("Illegal union index for 'F22': "+ unionIndex22)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(23, null); + } else { + if (unionIndex23 == 1) { + Utf8 charSequence23; + Object oldString23 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(23); + if (oldString23 instanceof Utf8) { + charSequence23 = (decoder).readString(((Utf8) oldString23)); + } else { + charSequence23 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(23, charSequence23); + } else { + throw new RuntimeException(("Illegal union index for 'F23': "+ unionIndex23)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(24, null); + } else { + if (unionIndex24 == 1) { + Utf8 charSequence24; + Object oldString24 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(24); + if (oldString24 instanceof Utf8) { + charSequence24 = (decoder).readString(((Utf8) oldString24)); + } else { + charSequence24 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(24, charSequence24); + } else { + throw new RuntimeException(("Illegal union index for 'F24': "+ unionIndex24)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(25, null); + } else { + if (unionIndex25 == 1) { + Utf8 charSequence25; + Object oldString25 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(25); + if (oldString25 instanceof Utf8) { + charSequence25 = (decoder).readString(((Utf8) oldString25)); + } else { + charSequence25 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(25, charSequence25); + } else { + throw new RuntimeException(("Illegal union index for 'F25': "+ unionIndex25)); + } + } + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(26, null); + } else { + if (unionIndex26 == 1) { + Utf8 charSequence26; + Object oldString26 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(26); + if (oldString26 instanceof Utf8) { + charSequence26 = (decoder).readString(((Utf8) oldString26)); + } else { + charSequence26 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(26, charSequence26); + } else { + throw new RuntimeException(("Illegal union index for 'F26': "+ unionIndex26)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex27 = (decoder.readIndex()); + if (unionIndex27 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(27, null); + } else { + if (unionIndex27 == 1) { + Utf8 charSequence27; + Object oldString27 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(27); + if (oldString27 instanceof Utf8) { + charSequence27 = (decoder).readString(((Utf8) oldString27)); + } else { + charSequence27 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(27, charSequence27); + } else { + throw new RuntimeException(("Illegal union index for 'F27': "+ unionIndex27)); + } + } + int unionIndex28 = (decoder.readIndex()); + if (unionIndex28 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(28, null); + } else { + if (unionIndex28 == 1) { + Utf8 charSequence28; + Object oldString28 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(28); + if (oldString28 instanceof Utf8) { + charSequence28 = (decoder).readString(((Utf8) oldString28)); + } else { + charSequence28 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(28, charSequence28); + } else { + throw new RuntimeException(("Illegal union index for 'F28': "+ unionIndex28)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex29 = (decoder.readIndex()); + if (unionIndex29 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(29, null); + } else { + if (unionIndex29 == 1) { + Utf8 charSequence29; + Object oldString29 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(29); + if (oldString29 instanceof Utf8) { + charSequence29 = (decoder).readString(((Utf8) oldString29)); + } else { + charSequence29 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(29, charSequence29); + } else { + throw new RuntimeException(("Illegal union index for 'F29': "+ unionIndex29)); + } + } + int unionIndex30 = (decoder.readIndex()); + if (unionIndex30 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(30, null); + } else { + if (unionIndex30 == 1) { + Utf8 charSequence30; + Object oldString30 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(30); + if (oldString30 instanceof Utf8) { + charSequence30 = (decoder).readString(((Utf8) oldString30)); + } else { + charSequence30 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(30, charSequence30); + } else { + throw new RuntimeException(("Illegal union index for 'F30': "+ unionIndex30)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex31 = (decoder.readIndex()); + if (unionIndex31 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(31, null); + } else { + if (unionIndex31 == 1) { + Utf8 charSequence31; + Object oldString31 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(31); + if (oldString31 instanceof Utf8) { + charSequence31 = (decoder).readString(((Utf8) oldString31)); + } else { + charSequence31 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(31, charSequence31); + } else { + throw new RuntimeException(("Illegal union index for 'F31': "+ unionIndex31)); + } + } + int unionIndex32 = (decoder.readIndex()); + if (unionIndex32 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(32, null); + } else { + if (unionIndex32 == 1) { + Utf8 charSequence32; + Object oldString32 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(32); + if (oldString32 instanceof Utf8) { + charSequence32 = (decoder).readString(((Utf8) oldString32)); + } else { + charSequence32 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(32, charSequence32); + } else { + throw new RuntimeException(("Illegal union index for 'F32': "+ unionIndex32)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex33 = (decoder.readIndex()); + if (unionIndex33 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(33, null); + } else { + if (unionIndex33 == 1) { + Utf8 charSequence33; + Object oldString33 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(33); + if (oldString33 instanceof Utf8) { + charSequence33 = (decoder).readString(((Utf8) oldString33)); + } else { + charSequence33 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(33, charSequence33); + } else { + throw new RuntimeException(("Illegal union index for 'F33': "+ unionIndex33)); + } + } + int unionIndex34 = (decoder.readIndex()); + if (unionIndex34 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(34, null); + } else { + if (unionIndex34 == 1) { + Utf8 charSequence34; + Object oldString34 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(34); + if (oldString34 instanceof Utf8) { + charSequence34 = (decoder).readString(((Utf8) oldString34)); + } else { + charSequence34 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(34, charSequence34); + } else { + throw new RuntimeException(("Illegal union index for 'F34': "+ unionIndex34)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex35 = (decoder.readIndex()); + if (unionIndex35 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(35, null); + } else { + if (unionIndex35 == 1) { + Utf8 charSequence35; + Object oldString35 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(35); + if (oldString35 instanceof Utf8) { + charSequence35 = (decoder).readString(((Utf8) oldString35)); + } else { + charSequence35 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(35, charSequence35); + } else { + throw new RuntimeException(("Illegal union index for 'F35': "+ unionIndex35)); + } + } + int unionIndex36 = (decoder.readIndex()); + if (unionIndex36 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(36, null); + } else { + if (unionIndex36 == 1) { + Utf8 charSequence36; + Object oldString36 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(36); + if (oldString36 instanceof Utf8) { + charSequence36 = (decoder).readString(((Utf8) oldString36)); + } else { + charSequence36 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(36, charSequence36); + } else { + throw new RuntimeException(("Illegal union index for 'F36': "+ unionIndex36)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex37 = (decoder.readIndex()); + if (unionIndex37 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(37, null); + } else { + if (unionIndex37 == 1) { + Utf8 charSequence37; + Object oldString37 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(37); + if (oldString37 instanceof Utf8) { + charSequence37 = (decoder).readString(((Utf8) oldString37)); + } else { + charSequence37 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(37, charSequence37); + } else { + throw new RuntimeException(("Illegal union index for 'F37': "+ unionIndex37)); + } + } + int unionIndex38 = (decoder.readIndex()); + if (unionIndex38 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(38, null); + } else { + if (unionIndex38 == 1) { + Utf8 charSequence38; + Object oldString38 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(38); + if (oldString38 instanceof Utf8) { + charSequence38 = (decoder).readString(((Utf8) oldString38)); + } else { + charSequence38 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(38, charSequence38); + } else { + throw new RuntimeException(("Illegal union index for 'F38': "+ unionIndex38)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex39 = (decoder.readIndex()); + if (unionIndex39 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(39, null); + } else { + if (unionIndex39 == 1) { + Utf8 charSequence39; + Object oldString39 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(39); + if (oldString39 instanceof Utf8) { + charSequence39 = (decoder).readString(((Utf8) oldString39)); + } else { + charSequence39 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(39, charSequence39); + } else { + throw new RuntimeException(("Illegal union index for 'F39': "+ unionIndex39)); + } + } + int unionIndex40 = (decoder.readIndex()); + if (unionIndex40 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(40, null); + } else { + if (unionIndex40 == 1) { + Utf8 charSequence40; + Object oldString40 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(40); + if (oldString40 instanceof Utf8) { + charSequence40 = (decoder).readString(((Utf8) oldString40)); + } else { + charSequence40 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(40, charSequence40); + } else { + throw new RuntimeException(("Illegal union index for 'F40': "+ unionIndex40)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex41 = (decoder.readIndex()); + if (unionIndex41 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(41, null); + } else { + if (unionIndex41 == 1) { + Utf8 charSequence41; + Object oldString41 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(41); + if (oldString41 instanceof Utf8) { + charSequence41 = (decoder).readString(((Utf8) oldString41)); + } else { + charSequence41 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(41, charSequence41); + } else { + throw new RuntimeException(("Illegal union index for 'F41': "+ unionIndex41)); + } + } + int unionIndex42 = (decoder.readIndex()); + if (unionIndex42 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(42, null); + } else { + if (unionIndex42 == 1) { + Utf8 charSequence42; + Object oldString42 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(42); + if (oldString42 instanceof Utf8) { + charSequence42 = (decoder).readString(((Utf8) oldString42)); + } else { + charSequence42 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(42, charSequence42); + } else { + throw new RuntimeException(("Illegal union index for 'F42': "+ unionIndex42)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex43 = (decoder.readIndex()); + if (unionIndex43 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(43, null); + } else { + if (unionIndex43 == 1) { + Utf8 charSequence43; + Object oldString43 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(43); + if (oldString43 instanceof Utf8) { + charSequence43 = (decoder).readString(((Utf8) oldString43)); + } else { + charSequence43 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(43, charSequence43); + } else { + throw new RuntimeException(("Illegal union index for 'F43': "+ unionIndex43)); + } + } + int unionIndex44 = (decoder.readIndex()); + if (unionIndex44 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(44, null); + } else { + if (unionIndex44 == 1) { + Utf8 charSequence44; + Object oldString44 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(44); + if (oldString44 instanceof Utf8) { + charSequence44 = (decoder).readString(((Utf8) oldString44)); + } else { + charSequence44 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(44, charSequence44); + } else { + throw new RuntimeException(("Illegal union index for 'F44': "+ unionIndex44)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex45 = (decoder.readIndex()); + if (unionIndex45 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(45, null); + } else { + if (unionIndex45 == 1) { + Utf8 charSequence45; + Object oldString45 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(45); + if (oldString45 instanceof Utf8) { + charSequence45 = (decoder).readString(((Utf8) oldString45)); + } else { + charSequence45 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(45, charSequence45); + } else { + throw new RuntimeException(("Illegal union index for 'F45': "+ unionIndex45)); + } + } + int unionIndex46 = (decoder.readIndex()); + if (unionIndex46 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(46, null); + } else { + if (unionIndex46 == 1) { + Utf8 charSequence46; + Object oldString46 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(46); + if (oldString46 instanceof Utf8) { + charSequence46 = (decoder).readString(((Utf8) oldString46)); + } else { + charSequence46 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(46, charSequence46); + } else { + throw new RuntimeException(("Illegal union index for 'F46': "+ unionIndex46)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex47 = (decoder.readIndex()); + if (unionIndex47 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(47, null); + } else { + if (unionIndex47 == 1) { + Utf8 charSequence47; + Object oldString47 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(47); + if (oldString47 instanceof Utf8) { + charSequence47 = (decoder).readString(((Utf8) oldString47)); + } else { + charSequence47 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(47, charSequence47); + } else { + throw new RuntimeException(("Illegal union index for 'F47': "+ unionIndex47)); + } + } + int unionIndex48 = (decoder.readIndex()); + if (unionIndex48 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(48, null); + } else { + if (unionIndex48 == 1) { + Utf8 charSequence48; + Object oldString48 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(48); + if (oldString48 instanceof Utf8) { + charSequence48 = (decoder).readString(((Utf8) oldString48)); + } else { + charSequence48 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(48, charSequence48); + } else { + throw new RuntimeException(("Illegal union index for 'F48': "+ unionIndex48)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex49 = (decoder.readIndex()); + if (unionIndex49 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(49, null); + } else { + if (unionIndex49 == 1) { + Utf8 charSequence49; + Object oldString49 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(49); + if (oldString49 instanceof Utf8) { + charSequence49 = (decoder).readString(((Utf8) oldString49)); + } else { + charSequence49 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(49, charSequence49); + } else { + throw new RuntimeException(("Illegal union index for 'F49': "+ unionIndex49)); + } + } + int unionIndex50 = (decoder.readIndex()); + if (unionIndex50 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(50, null); + } else { + if (unionIndex50 == 1) { + Utf8 charSequence50; + Object oldString50 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(50); + if (oldString50 instanceof Utf8) { + charSequence50 = (decoder).readString(((Utf8) oldString50)); + } else { + charSequence50 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(50, charSequence50); + } else { + throw new RuntimeException(("Illegal union index for 'F50': "+ unionIndex50)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex51 = (decoder.readIndex()); + if (unionIndex51 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(51, null); + } else { + if (unionIndex51 == 1) { + Utf8 charSequence51; + Object oldString51 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(51); + if (oldString51 instanceof Utf8) { + charSequence51 = (decoder).readString(((Utf8) oldString51)); + } else { + charSequence51 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(51, charSequence51); + } else { + throw new RuntimeException(("Illegal union index for 'F51': "+ unionIndex51)); + } + } + int unionIndex52 = (decoder.readIndex()); + if (unionIndex52 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(52, null); + } else { + if (unionIndex52 == 1) { + Utf8 charSequence52; + Object oldString52 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(52); + if (oldString52 instanceof Utf8) { + charSequence52 = (decoder).readString(((Utf8) oldString52)); + } else { + charSequence52 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(52, charSequence52); + } else { + throw new RuntimeException(("Illegal union index for 'F52': "+ unionIndex52)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex53 = (decoder.readIndex()); + if (unionIndex53 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(53, null); + } else { + if (unionIndex53 == 1) { + Utf8 charSequence53; + Object oldString53 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(53); + if (oldString53 instanceof Utf8) { + charSequence53 = (decoder).readString(((Utf8) oldString53)); + } else { + charSequence53 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(53, charSequence53); + } else { + throw new RuntimeException(("Illegal union index for 'F53': "+ unionIndex53)); + } + } + int unionIndex54 = (decoder.readIndex()); + if (unionIndex54 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(54, null); + } else { + if (unionIndex54 == 1) { + Utf8 charSequence54; + Object oldString54 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(54); + if (oldString54 instanceof Utf8) { + charSequence54 = (decoder).readString(((Utf8) oldString54)); + } else { + charSequence54 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(54, charSequence54); + } else { + throw new RuntimeException(("Illegal union index for 'F54': "+ unionIndex54)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex55 = (decoder.readIndex()); + if (unionIndex55 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(55, null); + } else { + if (unionIndex55 == 1) { + Utf8 charSequence55; + Object oldString55 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(55); + if (oldString55 instanceof Utf8) { + charSequence55 = (decoder).readString(((Utf8) oldString55)); + } else { + charSequence55 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(55, charSequence55); + } else { + throw new RuntimeException(("Illegal union index for 'F55': "+ unionIndex55)); + } + } + int unionIndex56 = (decoder.readIndex()); + if (unionIndex56 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(56, null); + } else { + if (unionIndex56 == 1) { + Utf8 charSequence56; + Object oldString56 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(56); + if (oldString56 instanceof Utf8) { + charSequence56 = (decoder).readString(((Utf8) oldString56)); + } else { + charSequence56 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(56, charSequence56); + } else { + throw new RuntimeException(("Illegal union index for 'F56': "+ unionIndex56)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex57 = (decoder.readIndex()); + if (unionIndex57 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(57, null); + } else { + if (unionIndex57 == 1) { + Utf8 charSequence57; + Object oldString57 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(57); + if (oldString57 instanceof Utf8) { + charSequence57 = (decoder).readString(((Utf8) oldString57)); + } else { + charSequence57 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(57, charSequence57); + } else { + throw new RuntimeException(("Illegal union index for 'F57': "+ unionIndex57)); + } + } + int unionIndex58 = (decoder.readIndex()); + if (unionIndex58 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(58, null); + } else { + if (unionIndex58 == 1) { + Utf8 charSequence58; + Object oldString58 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(58); + if (oldString58 instanceof Utf8) { + charSequence58 = (decoder).readString(((Utf8) oldString58)); + } else { + charSequence58 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(58, charSequence58); + } else { + throw new RuntimeException(("Illegal union index for 'F58': "+ unionIndex58)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex59 = (decoder.readIndex()); + if (unionIndex59 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(59, null); + } else { + if (unionIndex59 == 1) { + Utf8 charSequence59; + Object oldString59 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(59); + if (oldString59 instanceof Utf8) { + charSequence59 = (decoder).readString(((Utf8) oldString59)); + } else { + charSequence59 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(59, charSequence59); + } else { + throw new RuntimeException(("Illegal union index for 'F59': "+ unionIndex59)); + } + } + int unionIndex60 = (decoder.readIndex()); + if (unionIndex60 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(60, null); + } else { + if (unionIndex60 == 1) { + Utf8 charSequence60; + Object oldString60 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(60); + if (oldString60 instanceof Utf8) { + charSequence60 = (decoder).readString(((Utf8) oldString60)); + } else { + charSequence60 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(60, charSequence60); + } else { + throw new RuntimeException(("Illegal union index for 'F60': "+ unionIndex60)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex61 = (decoder.readIndex()); + if (unionIndex61 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(61, null); + } else { + if (unionIndex61 == 1) { + Utf8 charSequence61; + Object oldString61 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(61); + if (oldString61 instanceof Utf8) { + charSequence61 = (decoder).readString(((Utf8) oldString61)); + } else { + charSequence61 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(61, charSequence61); + } else { + throw new RuntimeException(("Illegal union index for 'F61': "+ unionIndex61)); + } + } + int unionIndex62 = (decoder.readIndex()); + if (unionIndex62 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(62, null); + } else { + if (unionIndex62 == 1) { + Utf8 charSequence62; + Object oldString62 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(62); + if (oldString62 instanceof Utf8) { + charSequence62 = (decoder).readString(((Utf8) oldString62)); + } else { + charSequence62 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(62, charSequence62); + } else { + throw new RuntimeException(("Illegal union index for 'F62': "+ unionIndex62)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex63 = (decoder.readIndex()); + if (unionIndex63 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(63, null); + } else { + if (unionIndex63 == 1) { + Utf8 charSequence63; + Object oldString63 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(63); + if (oldString63 instanceof Utf8) { + charSequence63 = (decoder).readString(((Utf8) oldString63)); + } else { + charSequence63 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(63, charSequence63); + } else { + throw new RuntimeException(("Illegal union index for 'F63': "+ unionIndex63)); + } + } + int unionIndex64 = (decoder.readIndex()); + if (unionIndex64 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(64, null); + } else { + if (unionIndex64 == 1) { + Utf8 charSequence64; + Object oldString64 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(64); + if (oldString64 instanceof Utf8) { + charSequence64 = (decoder).readString(((Utf8) oldString64)); + } else { + charSequence64 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(64, charSequence64); + } else { + throw new RuntimeException(("Illegal union index for 'F64': "+ unionIndex64)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex65 = (decoder.readIndex()); + if (unionIndex65 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(65, null); + } else { + if (unionIndex65 == 1) { + Utf8 charSequence65; + Object oldString65 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(65); + if (oldString65 instanceof Utf8) { + charSequence65 = (decoder).readString(((Utf8) oldString65)); + } else { + charSequence65 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(65, charSequence65); + } else { + throw new RuntimeException(("Illegal union index for 'F65': "+ unionIndex65)); + } + } + int unionIndex66 = (decoder.readIndex()); + if (unionIndex66 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(66, null); + } else { + if (unionIndex66 == 1) { + Utf8 charSequence66; + Object oldString66 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(66); + if (oldString66 instanceof Utf8) { + charSequence66 = (decoder).readString(((Utf8) oldString66)); + } else { + charSequence66 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(66, charSequence66); + } else { + throw new RuntimeException(("Illegal union index for 'F66': "+ unionIndex66)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex67 = (decoder.readIndex()); + if (unionIndex67 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(67, null); + } else { + if (unionIndex67 == 1) { + Utf8 charSequence67; + Object oldString67 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(67); + if (oldString67 instanceof Utf8) { + charSequence67 = (decoder).readString(((Utf8) oldString67)); + } else { + charSequence67 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(67, charSequence67); + } else { + throw new RuntimeException(("Illegal union index for 'F67': "+ unionIndex67)); + } + } + int unionIndex68 = (decoder.readIndex()); + if (unionIndex68 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(68, null); + } else { + if (unionIndex68 == 1) { + Utf8 charSequence68; + Object oldString68 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(68); + if (oldString68 instanceof Utf8) { + charSequence68 = (decoder).readString(((Utf8) oldString68)); + } else { + charSequence68 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(68, charSequence68); + } else { + throw new RuntimeException(("Illegal union index for 'F68': "+ unionIndex68)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex69 = (decoder.readIndex()); + if (unionIndex69 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(69, null); + } else { + if (unionIndex69 == 1) { + Utf8 charSequence69; + Object oldString69 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(69); + if (oldString69 instanceof Utf8) { + charSequence69 = (decoder).readString(((Utf8) oldString69)); + } else { + charSequence69 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(69, charSequence69); + } else { + throw new RuntimeException(("Illegal union index for 'F69': "+ unionIndex69)); + } + } + int unionIndex70 = (decoder.readIndex()); + if (unionIndex70 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(70, null); + } else { + if (unionIndex70 == 1) { + Utf8 charSequence70; + Object oldString70 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(70); + if (oldString70 instanceof Utf8) { + charSequence70 = (decoder).readString(((Utf8) oldString70)); + } else { + charSequence70 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(70, charSequence70); + } else { + throw new RuntimeException(("Illegal union index for 'F70': "+ unionIndex70)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex71 = (decoder.readIndex()); + if (unionIndex71 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(71, null); + } else { + if (unionIndex71 == 1) { + Utf8 charSequence71; + Object oldString71 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(71); + if (oldString71 instanceof Utf8) { + charSequence71 = (decoder).readString(((Utf8) oldString71)); + } else { + charSequence71 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(71, charSequence71); + } else { + throw new RuntimeException(("Illegal union index for 'F71': "+ unionIndex71)); + } + } + int unionIndex72 = (decoder.readIndex()); + if (unionIndex72 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(72, null); + } else { + if (unionIndex72 == 1) { + Utf8 charSequence72; + Object oldString72 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(72); + if (oldString72 instanceof Utf8) { + charSequence72 = (decoder).readString(((Utf8) oldString72)); + } else { + charSequence72 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(72, charSequence72); + } else { + throw new RuntimeException(("Illegal union index for 'F72': "+ unionIndex72)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex73 = (decoder.readIndex()); + if (unionIndex73 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(73, null); + } else { + if (unionIndex73 == 1) { + Utf8 charSequence73; + Object oldString73 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(73); + if (oldString73 instanceof Utf8) { + charSequence73 = (decoder).readString(((Utf8) oldString73)); + } else { + charSequence73 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(73, charSequence73); + } else { + throw new RuntimeException(("Illegal union index for 'F73': "+ unionIndex73)); + } + } + int unionIndex74 = (decoder.readIndex()); + if (unionIndex74 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(74, null); + } else { + if (unionIndex74 == 1) { + Utf8 charSequence74; + Object oldString74 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(74); + if (oldString74 instanceof Utf8) { + charSequence74 = (decoder).readString(((Utf8) oldString74)); + } else { + charSequence74 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(74, charSequence74); + } else { + throw new RuntimeException(("Illegal union index for 'F74': "+ unionIndex74)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex75 = (decoder.readIndex()); + if (unionIndex75 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(75, null); + } else { + if (unionIndex75 == 1) { + Utf8 charSequence75; + Object oldString75 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(75); + if (oldString75 instanceof Utf8) { + charSequence75 = (decoder).readString(((Utf8) oldString75)); + } else { + charSequence75 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(75, charSequence75); + } else { + throw new RuntimeException(("Illegal union index for 'F75': "+ unionIndex75)); + } + } + int unionIndex76 = (decoder.readIndex()); + if (unionIndex76 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(76, null); + } else { + if (unionIndex76 == 1) { + Utf8 charSequence76; + Object oldString76 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(76); + if (oldString76 instanceof Utf8) { + charSequence76 = (decoder).readString(((Utf8) oldString76)); + } else { + charSequence76 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(76, charSequence76); + } else { + throw new RuntimeException(("Illegal union index for 'F76': "+ unionIndex76)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex77 = (decoder.readIndex()); + if (unionIndex77 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(77, null); + } else { + if (unionIndex77 == 1) { + Utf8 charSequence77; + Object oldString77 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(77); + if (oldString77 instanceof Utf8) { + charSequence77 = (decoder).readString(((Utf8) oldString77)); + } else { + charSequence77 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(77, charSequence77); + } else { + throw new RuntimeException(("Illegal union index for 'F77': "+ unionIndex77)); + } + } + int unionIndex78 = (decoder.readIndex()); + if (unionIndex78 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(78, null); + } else { + if (unionIndex78 == 1) { + Utf8 charSequence78; + Object oldString78 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(78); + if (oldString78 instanceof Utf8) { + charSequence78 = (decoder).readString(((Utf8) oldString78)); + } else { + charSequence78 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(78, charSequence78); + } else { + throw new RuntimeException(("Illegal union index for 'F78': "+ unionIndex78)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex79 = (decoder.readIndex()); + if (unionIndex79 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(79, null); + } else { + if (unionIndex79 == 1) { + Utf8 charSequence79; + Object oldString79 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(79); + if (oldString79 instanceof Utf8) { + charSequence79 = (decoder).readString(((Utf8) oldString79)); + } else { + charSequence79 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(79, charSequence79); + } else { + throw new RuntimeException(("Illegal union index for 'F79': "+ unionIndex79)); + } + } + int unionIndex80 = (decoder.readIndex()); + if (unionIndex80 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(80, null); + } else { + if (unionIndex80 == 1) { + Utf8 charSequence80; + Object oldString80 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(80); + if (oldString80 instanceof Utf8) { + charSequence80 = (decoder).readString(((Utf8) oldString80)); + } else { + charSequence80 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(80, charSequence80); + } else { + throw new RuntimeException(("Illegal union index for 'F80': "+ unionIndex80)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex81 = (decoder.readIndex()); + if (unionIndex81 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(81, null); + } else { + if (unionIndex81 == 1) { + Utf8 charSequence81; + Object oldString81 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(81); + if (oldString81 instanceof Utf8) { + charSequence81 = (decoder).readString(((Utf8) oldString81)); + } else { + charSequence81 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(81, charSequence81); + } else { + throw new RuntimeException(("Illegal union index for 'F81': "+ unionIndex81)); + } + } + int unionIndex82 = (decoder.readIndex()); + if (unionIndex82 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(82, null); + } else { + if (unionIndex82 == 1) { + Utf8 charSequence82; + Object oldString82 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(82); + if (oldString82 instanceof Utf8) { + charSequence82 = (decoder).readString(((Utf8) oldString82)); + } else { + charSequence82 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(82, charSequence82); + } else { + throw new RuntimeException(("Illegal union index for 'F82': "+ unionIndex82)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex83 = (decoder.readIndex()); + if (unionIndex83 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(83, null); + } else { + if (unionIndex83 == 1) { + Utf8 charSequence83; + Object oldString83 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(83); + if (oldString83 instanceof Utf8) { + charSequence83 = (decoder).readString(((Utf8) oldString83)); + } else { + charSequence83 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(83, charSequence83); + } else { + throw new RuntimeException(("Illegal union index for 'F83': "+ unionIndex83)); + } + } + int unionIndex84 = (decoder.readIndex()); + if (unionIndex84 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(84, null); + } else { + if (unionIndex84 == 1) { + Utf8 charSequence84; + Object oldString84 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(84); + if (oldString84 instanceof Utf8) { + charSequence84 = (decoder).readString(((Utf8) oldString84)); + } else { + charSequence84 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(84, charSequence84); + } else { + throw new RuntimeException(("Illegal union index for 'F84': "+ unionIndex84)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex85 = (decoder.readIndex()); + if (unionIndex85 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(85, null); + } else { + if (unionIndex85 == 1) { + Utf8 charSequence85; + Object oldString85 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(85); + if (oldString85 instanceof Utf8) { + charSequence85 = (decoder).readString(((Utf8) oldString85)); + } else { + charSequence85 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(85, charSequence85); + } else { + throw new RuntimeException(("Illegal union index for 'F85': "+ unionIndex85)); + } + } + int unionIndex86 = (decoder.readIndex()); + if (unionIndex86 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(86, null); + } else { + if (unionIndex86 == 1) { + Utf8 charSequence86; + Object oldString86 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(86); + if (oldString86 instanceof Utf8) { + charSequence86 = (decoder).readString(((Utf8) oldString86)); + } else { + charSequence86 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(86, charSequence86); + } else { + throw new RuntimeException(("Illegal union index for 'F86': "+ unionIndex86)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex87 = (decoder.readIndex()); + if (unionIndex87 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(87, null); + } else { + if (unionIndex87 == 1) { + Utf8 charSequence87; + Object oldString87 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(87); + if (oldString87 instanceof Utf8) { + charSequence87 = (decoder).readString(((Utf8) oldString87)); + } else { + charSequence87 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(87, charSequence87); + } else { + throw new RuntimeException(("Illegal union index for 'F87': "+ unionIndex87)); + } + } + int unionIndex88 = (decoder.readIndex()); + if (unionIndex88 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(88, null); + } else { + if (unionIndex88 == 1) { + Utf8 charSequence88; + Object oldString88 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(88); + if (oldString88 instanceof Utf8) { + charSequence88 = (decoder).readString(((Utf8) oldString88)); + } else { + charSequence88 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(88, charSequence88); + } else { + throw new RuntimeException(("Illegal union index for 'F88': "+ unionIndex88)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex89 = (decoder.readIndex()); + if (unionIndex89 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(89, null); + } else { + if (unionIndex89 == 1) { + Utf8 charSequence89; + Object oldString89 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(89); + if (oldString89 instanceof Utf8) { + charSequence89 = (decoder).readString(((Utf8) oldString89)); + } else { + charSequence89 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(89, charSequence89); + } else { + throw new RuntimeException(("Illegal union index for 'F89': "+ unionIndex89)); + } + } + int unionIndex90 = (decoder.readIndex()); + if (unionIndex90 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(90, null); + } else { + if (unionIndex90 == 1) { + Utf8 charSequence90; + Object oldString90 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(90); + if (oldString90 instanceof Utf8) { + charSequence90 = (decoder).readString(((Utf8) oldString90)); + } else { + charSequence90 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(90, charSequence90); + } else { + throw new RuntimeException(("Illegal union index for 'F90': "+ unionIndex90)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex91 = (decoder.readIndex()); + if (unionIndex91 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(91, null); + } else { + if (unionIndex91 == 1) { + Utf8 charSequence91; + Object oldString91 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(91); + if (oldString91 instanceof Utf8) { + charSequence91 = (decoder).readString(((Utf8) oldString91)); + } else { + charSequence91 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(91, charSequence91); + } else { + throw new RuntimeException(("Illegal union index for 'F91': "+ unionIndex91)); + } + } + int unionIndex92 = (decoder.readIndex()); + if (unionIndex92 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(92, null); + } else { + if (unionIndex92 == 1) { + Utf8 charSequence92; + Object oldString92 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(92); + if (oldString92 instanceof Utf8) { + charSequence92 = (decoder).readString(((Utf8) oldString92)); + } else { + charSequence92 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(92, charSequence92); + } else { + throw new RuntimeException(("Illegal union index for 'F92': "+ unionIndex92)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex93 = (decoder.readIndex()); + if (unionIndex93 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(93, null); + } else { + if (unionIndex93 == 1) { + Utf8 charSequence93; + Object oldString93 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(93); + if (oldString93 instanceof Utf8) { + charSequence93 = (decoder).readString(((Utf8) oldString93)); + } else { + charSequence93 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(93, charSequence93); + } else { + throw new RuntimeException(("Illegal union index for 'F93': "+ unionIndex93)); + } + } + int unionIndex94 = (decoder.readIndex()); + if (unionIndex94 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(94, null); + } else { + if (unionIndex94 == 1) { + Utf8 charSequence94; + Object oldString94 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(94); + if (oldString94 instanceof Utf8) { + charSequence94 = (decoder).readString(((Utf8) oldString94)); + } else { + charSequence94 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(94, charSequence94); + } else { + throw new RuntimeException(("Illegal union index for 'F94': "+ unionIndex94)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex95 = (decoder.readIndex()); + if (unionIndex95 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(95, null); + } else { + if (unionIndex95 == 1) { + Utf8 charSequence95; + Object oldString95 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(95); + if (oldString95 instanceof Utf8) { + charSequence95 = (decoder).readString(((Utf8) oldString95)); + } else { + charSequence95 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(95, charSequence95); + } else { + throw new RuntimeException(("Illegal union index for 'F95': "+ unionIndex95)); + } + } + int unionIndex96 = (decoder.readIndex()); + if (unionIndex96 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(96, null); + } else { + if (unionIndex96 == 1) { + Utf8 charSequence96; + Object oldString96 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(96); + if (oldString96 instanceof Utf8) { + charSequence96 = (decoder).readString(((Utf8) oldString96)); + } else { + charSequence96 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(96, charSequence96); + } else { + throw new RuntimeException(("Illegal union index for 'F96': "+ unionIndex96)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex97 = (decoder.readIndex()); + if (unionIndex97 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(97, null); + } else { + if (unionIndex97 == 1) { + Utf8 charSequence97; + Object oldString97 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(97); + if (oldString97 instanceof Utf8) { + charSequence97 = (decoder).readString(((Utf8) oldString97)); + } else { + charSequence97 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(97, charSequence97); + } else { + throw new RuntimeException(("Illegal union index for 'F97': "+ unionIndex97)); + } + } + int unionIndex98 = (decoder.readIndex()); + if (unionIndex98 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(98, null); + } else { + if (unionIndex98 == 1) { + Utf8 charSequence98; + Object oldString98 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(98); + if (oldString98 instanceof Utf8) { + charSequence98 = (decoder).readString(((Utf8) oldString98)); + } else { + charSequence98 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(98, charSequence98); + } else { + throw new RuntimeException(("Illegal union index for 'F98': "+ unionIndex98)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex99 = (decoder.readIndex()); + if (unionIndex99 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(99, null); + } else { + if (unionIndex99 == 1) { + Utf8 charSequence99; + Object oldString99 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(99); + if (oldString99 instanceof Utf8) { + charSequence99 = (decoder).readString(((Utf8) oldString99)); + } else { + charSequence99 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(99, charSequence99); + } else { + throw new RuntimeException(("Illegal union index for 'F99': "+ unionIndex99)); + } + } + int unionIndex100 = (decoder.readIndex()); + if (unionIndex100 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(100, null); + } else { + if (unionIndex100 == 1) { + Utf8 charSequence100; + Object oldString100 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(100); + if (oldString100 instanceof Utf8) { + charSequence100 = (decoder).readString(((Utf8) oldString100)); + } else { + charSequence100 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(100, charSequence100); + } else { + throw new RuntimeException(("Illegal union index for 'F100': "+ unionIndex100)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex101 = (decoder.readIndex()); + if (unionIndex101 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(101, null); + } else { + if (unionIndex101 == 1) { + Utf8 charSequence101; + Object oldString101 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(101); + if (oldString101 instanceof Utf8) { + charSequence101 = (decoder).readString(((Utf8) oldString101)); + } else { + charSequence101 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(101, charSequence101); + } else { + throw new RuntimeException(("Illegal union index for 'F101': "+ unionIndex101)); + } + } + int unionIndex102 = (decoder.readIndex()); + if (unionIndex102 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(102, null); + } else { + if (unionIndex102 == 1) { + Utf8 charSequence102; + Object oldString102 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(102); + if (oldString102 instanceof Utf8) { + charSequence102 = (decoder).readString(((Utf8) oldString102)); + } else { + charSequence102 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(102, charSequence102); + } else { + throw new RuntimeException(("Illegal union index for 'F102': "+ unionIndex102)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex103 = (decoder.readIndex()); + if (unionIndex103 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(103, null); + } else { + if (unionIndex103 == 1) { + Utf8 charSequence103; + Object oldString103 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(103); + if (oldString103 instanceof Utf8) { + charSequence103 = (decoder).readString(((Utf8) oldString103)); + } else { + charSequence103 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(103, charSequence103); + } else { + throw new RuntimeException(("Illegal union index for 'F103': "+ unionIndex103)); + } + } + int unionIndex104 = (decoder.readIndex()); + if (unionIndex104 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(104, null); + } else { + if (unionIndex104 == 1) { + Utf8 charSequence104; + Object oldString104 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(104); + if (oldString104 instanceof Utf8) { + charSequence104 = (decoder).readString(((Utf8) oldString104)); + } else { + charSequence104 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(104, charSequence104); + } else { + throw new RuntimeException(("Illegal union index for 'F104': "+ unionIndex104)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex105 = (decoder.readIndex()); + if (unionIndex105 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(105, null); + } else { + if (unionIndex105 == 1) { + Utf8 charSequence105; + Object oldString105 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(105); + if (oldString105 instanceof Utf8) { + charSequence105 = (decoder).readString(((Utf8) oldString105)); + } else { + charSequence105 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(105, charSequence105); + } else { + throw new RuntimeException(("Illegal union index for 'F105': "+ unionIndex105)); + } + } + int unionIndex106 = (decoder.readIndex()); + if (unionIndex106 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(106, null); + } else { + if (unionIndex106 == 1) { + Utf8 charSequence106; + Object oldString106 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(106); + if (oldString106 instanceof Utf8) { + charSequence106 = (decoder).readString(((Utf8) oldString106)); + } else { + charSequence106 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(106, charSequence106); + } else { + throw new RuntimeException(("Illegal union index for 'F106': "+ unionIndex106)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex107 = (decoder.readIndex()); + if (unionIndex107 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(107, null); + } else { + if (unionIndex107 == 1) { + Utf8 charSequence107; + Object oldString107 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(107); + if (oldString107 instanceof Utf8) { + charSequence107 = (decoder).readString(((Utf8) oldString107)); + } else { + charSequence107 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(107, charSequence107); + } else { + throw new RuntimeException(("Illegal union index for 'F107': "+ unionIndex107)); + } + } + int unionIndex108 = (decoder.readIndex()); + if (unionIndex108 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(108, null); + } else { + if (unionIndex108 == 1) { + Utf8 charSequence108; + Object oldString108 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(108); + if (oldString108 instanceof Utf8) { + charSequence108 = (decoder).readString(((Utf8) oldString108)); + } else { + charSequence108 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(108, charSequence108); + } else { + throw new RuntimeException(("Illegal union index for 'F108': "+ unionIndex108)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex109 = (decoder.readIndex()); + if (unionIndex109 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(109, null); + } else { + if (unionIndex109 == 1) { + Utf8 charSequence109; + Object oldString109 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(109); + if (oldString109 instanceof Utf8) { + charSequence109 = (decoder).readString(((Utf8) oldString109)); + } else { + charSequence109 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(109, charSequence109); + } else { + throw new RuntimeException(("Illegal union index for 'F109': "+ unionIndex109)); + } + } + int unionIndex110 = (decoder.readIndex()); + if (unionIndex110 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(110, null); + } else { + if (unionIndex110 == 1) { + Utf8 charSequence110; + Object oldString110 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(110); + if (oldString110 instanceof Utf8) { + charSequence110 = (decoder).readString(((Utf8) oldString110)); + } else { + charSequence110 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(110, charSequence110); + } else { + throw new RuntimeException(("Illegal union index for 'F110': "+ unionIndex110)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex111 = (decoder.readIndex()); + if (unionIndex111 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(111, null); + } else { + if (unionIndex111 == 1) { + Utf8 charSequence111; + Object oldString111 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(111); + if (oldString111 instanceof Utf8) { + charSequence111 = (decoder).readString(((Utf8) oldString111)); + } else { + charSequence111 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(111, charSequence111); + } else { + throw new RuntimeException(("Illegal union index for 'F111': "+ unionIndex111)); + } + } + int unionIndex112 = (decoder.readIndex()); + if (unionIndex112 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(112, null); + } else { + if (unionIndex112 == 1) { + Utf8 charSequence112; + Object oldString112 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(112); + if (oldString112 instanceof Utf8) { + charSequence112 = (decoder).readString(((Utf8) oldString112)); + } else { + charSequence112 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(112, charSequence112); + } else { + throw new RuntimeException(("Illegal union index for 'F112': "+ unionIndex112)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex113 = (decoder.readIndex()); + if (unionIndex113 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(113, null); + } else { + if (unionIndex113 == 1) { + Utf8 charSequence113; + Object oldString113 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(113); + if (oldString113 instanceof Utf8) { + charSequence113 = (decoder).readString(((Utf8) oldString113)); + } else { + charSequence113 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(113, charSequence113); + } else { + throw new RuntimeException(("Illegal union index for 'F113': "+ unionIndex113)); + } + } + int unionIndex114 = (decoder.readIndex()); + if (unionIndex114 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(114, null); + } else { + if (unionIndex114 == 1) { + Utf8 charSequence114; + Object oldString114 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(114); + if (oldString114 instanceof Utf8) { + charSequence114 = (decoder).readString(((Utf8) oldString114)); + } else { + charSequence114 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(114, charSequence114); + } else { + throw new RuntimeException(("Illegal union index for 'F114': "+ unionIndex114)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex115 = (decoder.readIndex()); + if (unionIndex115 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(115, null); + } else { + if (unionIndex115 == 1) { + Utf8 charSequence115; + Object oldString115 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(115); + if (oldString115 instanceof Utf8) { + charSequence115 = (decoder).readString(((Utf8) oldString115)); + } else { + charSequence115 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(115, charSequence115); + } else { + throw new RuntimeException(("Illegal union index for 'F115': "+ unionIndex115)); + } + } + int unionIndex116 = (decoder.readIndex()); + if (unionIndex116 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(116, null); + } else { + if (unionIndex116 == 1) { + Utf8 charSequence116; + Object oldString116 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(116); + if (oldString116 instanceof Utf8) { + charSequence116 = (decoder).readString(((Utf8) oldString116)); + } else { + charSequence116 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(116, charSequence116); + } else { + throw new RuntimeException(("Illegal union index for 'F116': "+ unionIndex116)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex117 = (decoder.readIndex()); + if (unionIndex117 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(117, null); + } else { + if (unionIndex117 == 1) { + Utf8 charSequence117; + Object oldString117 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(117); + if (oldString117 instanceof Utf8) { + charSequence117 = (decoder).readString(((Utf8) oldString117)); + } else { + charSequence117 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(117, charSequence117); + } else { + throw new RuntimeException(("Illegal union index for 'F117': "+ unionIndex117)); + } + } + int unionIndex118 = (decoder.readIndex()); + if (unionIndex118 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(118, null); + } else { + if (unionIndex118 == 1) { + Utf8 charSequence118; + Object oldString118 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(118); + if (oldString118 instanceof Utf8) { + charSequence118 = (decoder).readString(((Utf8) oldString118)); + } else { + charSequence118 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(118, charSequence118); + } else { + throw new RuntimeException(("Illegal union index for 'F118': "+ unionIndex118)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex119 = (decoder.readIndex()); + if (unionIndex119 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(119, null); + } else { + if (unionIndex119 == 1) { + Utf8 charSequence119; + Object oldString119 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(119); + if (oldString119 instanceof Utf8) { + charSequence119 = (decoder).readString(((Utf8) oldString119)); + } else { + charSequence119 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(119, charSequence119); + } else { + throw new RuntimeException(("Illegal union index for 'F119': "+ unionIndex119)); + } + } + int unionIndex120 = (decoder.readIndex()); + if (unionIndex120 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(120, null); + } else { + if (unionIndex120 == 1) { + Utf8 charSequence120; + Object oldString120 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(120); + if (oldString120 instanceof Utf8) { + charSequence120 = (decoder).readString(((Utf8) oldString120)); + } else { + charSequence120 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(120, charSequence120); + } else { + throw new RuntimeException(("Illegal union index for 'F120': "+ unionIndex120)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex121 = (decoder.readIndex()); + if (unionIndex121 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(121, null); + } else { + if (unionIndex121 == 1) { + Utf8 charSequence121; + Object oldString121 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(121); + if (oldString121 instanceof Utf8) { + charSequence121 = (decoder).readString(((Utf8) oldString121)); + } else { + charSequence121 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(121, charSequence121); + } else { + throw new RuntimeException(("Illegal union index for 'F121': "+ unionIndex121)); + } + } + int unionIndex122 = (decoder.readIndex()); + if (unionIndex122 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(122, null); + } else { + if (unionIndex122 == 1) { + Utf8 charSequence122; + Object oldString122 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(122); + if (oldString122 instanceof Utf8) { + charSequence122 = (decoder).readString(((Utf8) oldString122)); + } else { + charSequence122 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(122, charSequence122); + } else { + throw new RuntimeException(("Illegal union index for 'F122': "+ unionIndex122)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex123 = (decoder.readIndex()); + if (unionIndex123 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(123, null); + } else { + if (unionIndex123 == 1) { + Utf8 charSequence123; + Object oldString123 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(123); + if (oldString123 instanceof Utf8) { + charSequence123 = (decoder).readString(((Utf8) oldString123)); + } else { + charSequence123 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(123, charSequence123); + } else { + throw new RuntimeException(("Illegal union index for 'F123': "+ unionIndex123)); + } + } + int unionIndex124 = (decoder.readIndex()); + if (unionIndex124 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(124, null); + } else { + if (unionIndex124 == 1) { + Utf8 charSequence124; + Object oldString124 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(124); + if (oldString124 instanceof Utf8) { + charSequence124 = (decoder).readString(((Utf8) oldString124)); + } else { + charSequence124 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(124, charSequence124); + } else { + throw new RuntimeException(("Illegal union index for 'F124': "+ unionIndex124)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex125 = (decoder.readIndex()); + if (unionIndex125 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(125, null); + } else { + if (unionIndex125 == 1) { + Utf8 charSequence125; + Object oldString125 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(125); + if (oldString125 instanceof Utf8) { + charSequence125 = (decoder).readString(((Utf8) oldString125)); + } else { + charSequence125 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(125, charSequence125); + } else { + throw new RuntimeException(("Illegal union index for 'F125': "+ unionIndex125)); + } + } + int unionIndex126 = (decoder.readIndex()); + if (unionIndex126 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(126, null); + } else { + if (unionIndex126 == 1) { + Utf8 charSequence126; + Object oldString126 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(126); + if (oldString126 instanceof Utf8) { + charSequence126 = (decoder).readString(((Utf8) oldString126)); + } else { + charSequence126 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(126, charSequence126); + } else { + throw new RuntimeException(("Illegal union index for 'F126': "+ unionIndex126)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex127 = (decoder.readIndex()); + if (unionIndex127 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(127, null); + } else { + if (unionIndex127 == 1) { + Utf8 charSequence127; + Object oldString127 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(127); + if (oldString127 instanceof Utf8) { + charSequence127 = (decoder).readString(((Utf8) oldString127)); + } else { + charSequence127 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(127, charSequence127); + } else { + throw new RuntimeException(("Illegal union index for 'F127': "+ unionIndex127)); + } + } + int unionIndex128 = (decoder.readIndex()); + if (unionIndex128 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(128, null); + } else { + if (unionIndex128 == 1) { + Utf8 charSequence128; + Object oldString128 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(128); + if (oldString128 instanceof Utf8) { + charSequence128 = (decoder).readString(((Utf8) oldString128)); + } else { + charSequence128 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(128, charSequence128); + } else { + throw new RuntimeException(("Illegal union index for 'F128': "+ unionIndex128)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex129 = (decoder.readIndex()); + if (unionIndex129 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(129, null); + } else { + if (unionIndex129 == 1) { + Utf8 charSequence129; + Object oldString129 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(129); + if (oldString129 instanceof Utf8) { + charSequence129 = (decoder).readString(((Utf8) oldString129)); + } else { + charSequence129 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(129, charSequence129); + } else { + throw new RuntimeException(("Illegal union index for 'F129': "+ unionIndex129)); + } + } + int unionIndex130 = (decoder.readIndex()); + if (unionIndex130 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(130, null); + } else { + if (unionIndex130 == 1) { + Utf8 charSequence130; + Object oldString130 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(130); + if (oldString130 instanceof Utf8) { + charSequence130 = (decoder).readString(((Utf8) oldString130)); + } else { + charSequence130 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(130, charSequence130); + } else { + throw new RuntimeException(("Illegal union index for 'F130': "+ unionIndex130)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex131 = (decoder.readIndex()); + if (unionIndex131 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(131, null); + } else { + if (unionIndex131 == 1) { + Utf8 charSequence131; + Object oldString131 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(131); + if (oldString131 instanceof Utf8) { + charSequence131 = (decoder).readString(((Utf8) oldString131)); + } else { + charSequence131 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(131, charSequence131); + } else { + throw new RuntimeException(("Illegal union index for 'F131': "+ unionIndex131)); + } + } + int unionIndex132 = (decoder.readIndex()); + if (unionIndex132 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(132, null); + } else { + if (unionIndex132 == 1) { + Utf8 charSequence132; + Object oldString132 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(132); + if (oldString132 instanceof Utf8) { + charSequence132 = (decoder).readString(((Utf8) oldString132)); + } else { + charSequence132 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(132, charSequence132); + } else { + throw new RuntimeException(("Illegal union index for 'F132': "+ unionIndex132)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex133 = (decoder.readIndex()); + if (unionIndex133 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(133, null); + } else { + if (unionIndex133 == 1) { + Utf8 charSequence133; + Object oldString133 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(133); + if (oldString133 instanceof Utf8) { + charSequence133 = (decoder).readString(((Utf8) oldString133)); + } else { + charSequence133 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(133, charSequence133); + } else { + throw new RuntimeException(("Illegal union index for 'F133': "+ unionIndex133)); + } + } + int unionIndex134 = (decoder.readIndex()); + if (unionIndex134 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(134, null); + } else { + if (unionIndex134 == 1) { + Utf8 charSequence134; + Object oldString134 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(134); + if (oldString134 instanceof Utf8) { + charSequence134 = (decoder).readString(((Utf8) oldString134)); + } else { + charSequence134 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(134, charSequence134); + } else { + throw new RuntimeException(("Illegal union index for 'F134': "+ unionIndex134)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex135 = (decoder.readIndex()); + if (unionIndex135 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(135, null); + } else { + if (unionIndex135 == 1) { + Utf8 charSequence135; + Object oldString135 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(135); + if (oldString135 instanceof Utf8) { + charSequence135 = (decoder).readString(((Utf8) oldString135)); + } else { + charSequence135 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(135, charSequence135); + } else { + throw new RuntimeException(("Illegal union index for 'F135': "+ unionIndex135)); + } + } + int unionIndex136 = (decoder.readIndex()); + if (unionIndex136 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(136, null); + } else { + if (unionIndex136 == 1) { + Utf8 charSequence136; + Object oldString136 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(136); + if (oldString136 instanceof Utf8) { + charSequence136 = (decoder).readString(((Utf8) oldString136)); + } else { + charSequence136 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(136, charSequence136); + } else { + throw new RuntimeException(("Illegal union index for 'F136': "+ unionIndex136)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex137 = (decoder.readIndex()); + if (unionIndex137 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(137, null); + } else { + if (unionIndex137 == 1) { + Utf8 charSequence137; + Object oldString137 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(137); + if (oldString137 instanceof Utf8) { + charSequence137 = (decoder).readString(((Utf8) oldString137)); + } else { + charSequence137 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(137, charSequence137); + } else { + throw new RuntimeException(("Illegal union index for 'F137': "+ unionIndex137)); + } + } + int unionIndex138 = (decoder.readIndex()); + if (unionIndex138 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(138, null); + } else { + if (unionIndex138 == 1) { + Utf8 charSequence138; + Object oldString138 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(138); + if (oldString138 instanceof Utf8) { + charSequence138 = (decoder).readString(((Utf8) oldString138)); + } else { + charSequence138 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(138, charSequence138); + } else { + throw new RuntimeException(("Illegal union index for 'F138': "+ unionIndex138)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex139 = (decoder.readIndex()); + if (unionIndex139 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(139, null); + } else { + if (unionIndex139 == 1) { + Utf8 charSequence139; + Object oldString139 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(139); + if (oldString139 instanceof Utf8) { + charSequence139 = (decoder).readString(((Utf8) oldString139)); + } else { + charSequence139 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(139, charSequence139); + } else { + throw new RuntimeException(("Illegal union index for 'F139': "+ unionIndex139)); + } + } + int unionIndex140 = (decoder.readIndex()); + if (unionIndex140 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(140, null); + } else { + if (unionIndex140 == 1) { + Utf8 charSequence140; + Object oldString140 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(140); + if (oldString140 instanceof Utf8) { + charSequence140 = (decoder).readString(((Utf8) oldString140)); + } else { + charSequence140 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(140, charSequence140); + } else { + throw new RuntimeException(("Illegal union index for 'F140': "+ unionIndex140)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex141 = (decoder.readIndex()); + if (unionIndex141 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(141, null); + } else { + if (unionIndex141 == 1) { + Utf8 charSequence141; + Object oldString141 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(141); + if (oldString141 instanceof Utf8) { + charSequence141 = (decoder).readString(((Utf8) oldString141)); + } else { + charSequence141 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(141, charSequence141); + } else { + throw new RuntimeException(("Illegal union index for 'F141': "+ unionIndex141)); + } + } + int unionIndex142 = (decoder.readIndex()); + if (unionIndex142 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(142, null); + } else { + if (unionIndex142 == 1) { + Utf8 charSequence142; + Object oldString142 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(142); + if (oldString142 instanceof Utf8) { + charSequence142 = (decoder).readString(((Utf8) oldString142)); + } else { + charSequence142 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(142, charSequence142); + } else { + throw new RuntimeException(("Illegal union index for 'F142': "+ unionIndex142)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex143 = (decoder.readIndex()); + if (unionIndex143 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(143, null); + } else { + if (unionIndex143 == 1) { + Utf8 charSequence143; + Object oldString143 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(143); + if (oldString143 instanceof Utf8) { + charSequence143 = (decoder).readString(((Utf8) oldString143)); + } else { + charSequence143 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(143, charSequence143); + } else { + throw new RuntimeException(("Illegal union index for 'F143': "+ unionIndex143)); + } + } + int unionIndex144 = (decoder.readIndex()); + if (unionIndex144 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(144, null); + } else { + if (unionIndex144 == 1) { + Utf8 charSequence144; + Object oldString144 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(144); + if (oldString144 instanceof Utf8) { + charSequence144 = (decoder).readString(((Utf8) oldString144)); + } else { + charSequence144 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(144, charSequence144); + } else { + throw new RuntimeException(("Illegal union index for 'F144': "+ unionIndex144)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex145 = (decoder.readIndex()); + if (unionIndex145 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(145, null); + } else { + if (unionIndex145 == 1) { + Utf8 charSequence145; + Object oldString145 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(145); + if (oldString145 instanceof Utf8) { + charSequence145 = (decoder).readString(((Utf8) oldString145)); + } else { + charSequence145 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(145, charSequence145); + } else { + throw new RuntimeException(("Illegal union index for 'F145': "+ unionIndex145)); + } + } + int unionIndex146 = (decoder.readIndex()); + if (unionIndex146 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(146, null); + } else { + if (unionIndex146 == 1) { + Utf8 charSequence146; + Object oldString146 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(146); + if (oldString146 instanceof Utf8) { + charSequence146 = (decoder).readString(((Utf8) oldString146)); + } else { + charSequence146 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(146, charSequence146); + } else { + throw new RuntimeException(("Illegal union index for 'F146': "+ unionIndex146)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex147 = (decoder.readIndex()); + if (unionIndex147 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(147, null); + } else { + if (unionIndex147 == 1) { + Utf8 charSequence147; + Object oldString147 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(147); + if (oldString147 instanceof Utf8) { + charSequence147 = (decoder).readString(((Utf8) oldString147)); + } else { + charSequence147 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(147, charSequence147); + } else { + throw new RuntimeException(("Illegal union index for 'F147': "+ unionIndex147)); + } + } + int unionIndex148 = (decoder.readIndex()); + if (unionIndex148 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(148, null); + } else { + if (unionIndex148 == 1) { + Utf8 charSequence148; + Object oldString148 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(148); + if (oldString148 instanceof Utf8) { + charSequence148 = (decoder).readString(((Utf8) oldString148)); + } else { + charSequence148 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(148, charSequence148); + } else { + throw new RuntimeException(("Illegal union index for 'F148': "+ unionIndex148)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex149 = (decoder.readIndex()); + if (unionIndex149 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(149, null); + } else { + if (unionIndex149 == 1) { + Utf8 charSequence149; + Object oldString149 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(149); + if (oldString149 instanceof Utf8) { + charSequence149 = (decoder).readString(((Utf8) oldString149)); + } else { + charSequence149 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(149, charSequence149); + } else { + throw new RuntimeException(("Illegal union index for 'F149': "+ unionIndex149)); + } + } + int unionIndex150 = (decoder.readIndex()); + if (unionIndex150 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(150, null); + } else { + if (unionIndex150 == 1) { + Utf8 charSequence150; + Object oldString150 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(150); + if (oldString150 instanceof Utf8) { + charSequence150 = (decoder).readString(((Utf8) oldString150)); + } else { + charSequence150 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(150, charSequence150); + } else { + throw new RuntimeException(("Illegal union index for 'F150': "+ unionIndex150)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex151 = (decoder.readIndex()); + if (unionIndex151 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(151, null); + } else { + if (unionIndex151 == 1) { + Utf8 charSequence151; + Object oldString151 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(151); + if (oldString151 instanceof Utf8) { + charSequence151 = (decoder).readString(((Utf8) oldString151)); + } else { + charSequence151 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(151, charSequence151); + } else { + throw new RuntimeException(("Illegal union index for 'F151': "+ unionIndex151)); + } + } + int unionIndex152 = (decoder.readIndex()); + if (unionIndex152 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(152, null); + } else { + if (unionIndex152 == 1) { + Utf8 charSequence152; + Object oldString152 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(152); + if (oldString152 instanceof Utf8) { + charSequence152 = (decoder).readString(((Utf8) oldString152)); + } else { + charSequence152 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(152, charSequence152); + } else { + throw new RuntimeException(("Illegal union index for 'F152': "+ unionIndex152)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex153 = (decoder.readIndex()); + if (unionIndex153 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(153, null); + } else { + if (unionIndex153 == 1) { + Utf8 charSequence153; + Object oldString153 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(153); + if (oldString153 instanceof Utf8) { + charSequence153 = (decoder).readString(((Utf8) oldString153)); + } else { + charSequence153 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(153, charSequence153); + } else { + throw new RuntimeException(("Illegal union index for 'F153': "+ unionIndex153)); + } + } + int unionIndex154 = (decoder.readIndex()); + if (unionIndex154 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(154, null); + } else { + if (unionIndex154 == 1) { + Utf8 charSequence154; + Object oldString154 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(154); + if (oldString154 instanceof Utf8) { + charSequence154 = (decoder).readString(((Utf8) oldString154)); + } else { + charSequence154 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(154, charSequence154); + } else { + throw new RuntimeException(("Illegal union index for 'F154': "+ unionIndex154)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex155 = (decoder.readIndex()); + if (unionIndex155 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(155, null); + } else { + if (unionIndex155 == 1) { + Utf8 charSequence155; + Object oldString155 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(155); + if (oldString155 instanceof Utf8) { + charSequence155 = (decoder).readString(((Utf8) oldString155)); + } else { + charSequence155 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(155, charSequence155); + } else { + throw new RuntimeException(("Illegal union index for 'F155': "+ unionIndex155)); + } + } + int unionIndex156 = (decoder.readIndex()); + if (unionIndex156 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(156, null); + } else { + if (unionIndex156 == 1) { + Utf8 charSequence156; + Object oldString156 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(156); + if (oldString156 instanceof Utf8) { + charSequence156 = (decoder).readString(((Utf8) oldString156)); + } else { + charSequence156 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(156, charSequence156); + } else { + throw new RuntimeException(("Illegal union index for 'F156': "+ unionIndex156)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex157 = (decoder.readIndex()); + if (unionIndex157 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(157, null); + } else { + if (unionIndex157 == 1) { + Utf8 charSequence157; + Object oldString157 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(157); + if (oldString157 instanceof Utf8) { + charSequence157 = (decoder).readString(((Utf8) oldString157)); + } else { + charSequence157 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(157, charSequence157); + } else { + throw new RuntimeException(("Illegal union index for 'F157': "+ unionIndex157)); + } + } + int unionIndex158 = (decoder.readIndex()); + if (unionIndex158 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(158, null); + } else { + if (unionIndex158 == 1) { + Utf8 charSequence158; + Object oldString158 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(158); + if (oldString158 instanceof Utf8) { + charSequence158 = (decoder).readString(((Utf8) oldString158)); + } else { + charSequence158 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(158, charSequence158); + } else { + throw new RuntimeException(("Illegal union index for 'F158': "+ unionIndex158)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex159 = (decoder.readIndex()); + if (unionIndex159 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(159, null); + } else { + if (unionIndex159 == 1) { + Utf8 charSequence159; + Object oldString159 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(159); + if (oldString159 instanceof Utf8) { + charSequence159 = (decoder).readString(((Utf8) oldString159)); + } else { + charSequence159 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(159, charSequence159); + } else { + throw new RuntimeException(("Illegal union index for 'F159': "+ unionIndex159)); + } + } + int unionIndex160 = (decoder.readIndex()); + if (unionIndex160 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(160, null); + } else { + if (unionIndex160 == 1) { + Utf8 charSequence160; + Object oldString160 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(160); + if (oldString160 instanceof Utf8) { + charSequence160 = (decoder).readString(((Utf8) oldString160)); + } else { + charSequence160 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(160, charSequence160); + } else { + throw new RuntimeException(("Illegal union index for 'F160': "+ unionIndex160)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex161 = (decoder.readIndex()); + if (unionIndex161 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(161, null); + } else { + if (unionIndex161 == 1) { + Utf8 charSequence161; + Object oldString161 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(161); + if (oldString161 instanceof Utf8) { + charSequence161 = (decoder).readString(((Utf8) oldString161)); + } else { + charSequence161 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(161, charSequence161); + } else { + throw new RuntimeException(("Illegal union index for 'F161': "+ unionIndex161)); + } + } + int unionIndex162 = (decoder.readIndex()); + if (unionIndex162 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(162, null); + } else { + if (unionIndex162 == 1) { + Utf8 charSequence162; + Object oldString162 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(162); + if (oldString162 instanceof Utf8) { + charSequence162 = (decoder).readString(((Utf8) oldString162)); + } else { + charSequence162 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(162, charSequence162); + } else { + throw new RuntimeException(("Illegal union index for 'F162': "+ unionIndex162)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex163 = (decoder.readIndex()); + if (unionIndex163 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(163, null); + } else { + if (unionIndex163 == 1) { + Utf8 charSequence163; + Object oldString163 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(163); + if (oldString163 instanceof Utf8) { + charSequence163 = (decoder).readString(((Utf8) oldString163)); + } else { + charSequence163 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(163, charSequence163); + } else { + throw new RuntimeException(("Illegal union index for 'F163': "+ unionIndex163)); + } + } + int unionIndex164 = (decoder.readIndex()); + if (unionIndex164 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(164, null); + } else { + if (unionIndex164 == 1) { + Utf8 charSequence164; + Object oldString164 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(164); + if (oldString164 instanceof Utf8) { + charSequence164 = (decoder).readString(((Utf8) oldString164)); + } else { + charSequence164 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(164, charSequence164); + } else { + throw new RuntimeException(("Illegal union index for 'F164': "+ unionIndex164)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex165 = (decoder.readIndex()); + if (unionIndex165 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(165, null); + } else { + if (unionIndex165 == 1) { + Utf8 charSequence165; + Object oldString165 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(165); + if (oldString165 instanceof Utf8) { + charSequence165 = (decoder).readString(((Utf8) oldString165)); + } else { + charSequence165 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(165, charSequence165); + } else { + throw new RuntimeException(("Illegal union index for 'F165': "+ unionIndex165)); + } + } + int unionIndex166 = (decoder.readIndex()); + if (unionIndex166 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(166, null); + } else { + if (unionIndex166 == 1) { + Utf8 charSequence166; + Object oldString166 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(166); + if (oldString166 instanceof Utf8) { + charSequence166 = (decoder).readString(((Utf8) oldString166)); + } else { + charSequence166 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(166, charSequence166); + } else { + throw new RuntimeException(("Illegal union index for 'F166': "+ unionIndex166)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex167 = (decoder.readIndex()); + if (unionIndex167 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(167, null); + } else { + if (unionIndex167 == 1) { + Utf8 charSequence167; + Object oldString167 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(167); + if (oldString167 instanceof Utf8) { + charSequence167 = (decoder).readString(((Utf8) oldString167)); + } else { + charSequence167 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(167, charSequence167); + } else { + throw new RuntimeException(("Illegal union index for 'F167': "+ unionIndex167)); + } + } + int unionIndex168 = (decoder.readIndex()); + if (unionIndex168 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(168, null); + } else { + if (unionIndex168 == 1) { + Utf8 charSequence168; + Object oldString168 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(168); + if (oldString168 instanceof Utf8) { + charSequence168 = (decoder).readString(((Utf8) oldString168)); + } else { + charSequence168 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(168, charSequence168); + } else { + throw new RuntimeException(("Illegal union index for 'F168': "+ unionIndex168)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex169 = (decoder.readIndex()); + if (unionIndex169 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(169, null); + } else { + if (unionIndex169 == 1) { + Utf8 charSequence169; + Object oldString169 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(169); + if (oldString169 instanceof Utf8) { + charSequence169 = (decoder).readString(((Utf8) oldString169)); + } else { + charSequence169 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(169, charSequence169); + } else { + throw new RuntimeException(("Illegal union index for 'F169': "+ unionIndex169)); + } + } + int unionIndex170 = (decoder.readIndex()); + if (unionIndex170 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(170, null); + } else { + if (unionIndex170 == 1) { + Utf8 charSequence170; + Object oldString170 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(170); + if (oldString170 instanceof Utf8) { + charSequence170 = (decoder).readString(((Utf8) oldString170)); + } else { + charSequence170 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(170, charSequence170); + } else { + throw new RuntimeException(("Illegal union index for 'F170': "+ unionIndex170)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex171 = (decoder.readIndex()); + if (unionIndex171 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(171, null); + } else { + if (unionIndex171 == 1) { + Utf8 charSequence171; + Object oldString171 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(171); + if (oldString171 instanceof Utf8) { + charSequence171 = (decoder).readString(((Utf8) oldString171)); + } else { + charSequence171 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(171, charSequence171); + } else { + throw new RuntimeException(("Illegal union index for 'F171': "+ unionIndex171)); + } + } + int unionIndex172 = (decoder.readIndex()); + if (unionIndex172 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(172, null); + } else { + if (unionIndex172 == 1) { + Utf8 charSequence172; + Object oldString172 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(172); + if (oldString172 instanceof Utf8) { + charSequence172 = (decoder).readString(((Utf8) oldString172)); + } else { + charSequence172 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(172, charSequence172); + } else { + throw new RuntimeException(("Illegal union index for 'F172': "+ unionIndex172)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex173 = (decoder.readIndex()); + if (unionIndex173 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(173, null); + } else { + if (unionIndex173 == 1) { + Utf8 charSequence173; + Object oldString173 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(173); + if (oldString173 instanceof Utf8) { + charSequence173 = (decoder).readString(((Utf8) oldString173)); + } else { + charSequence173 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(173, charSequence173); + } else { + throw new RuntimeException(("Illegal union index for 'F173': "+ unionIndex173)); + } + } + int unionIndex174 = (decoder.readIndex()); + if (unionIndex174 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(174, null); + } else { + if (unionIndex174 == 1) { + Utf8 charSequence174; + Object oldString174 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(174); + if (oldString174 instanceof Utf8) { + charSequence174 = (decoder).readString(((Utf8) oldString174)); + } else { + charSequence174 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(174, charSequence174); + } else { + throw new RuntimeException(("Illegal union index for 'F174': "+ unionIndex174)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex175 = (decoder.readIndex()); + if (unionIndex175 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(175, null); + } else { + if (unionIndex175 == 1) { + Utf8 charSequence175; + Object oldString175 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(175); + if (oldString175 instanceof Utf8) { + charSequence175 = (decoder).readString(((Utf8) oldString175)); + } else { + charSequence175 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(175, charSequence175); + } else { + throw new RuntimeException(("Illegal union index for 'F175': "+ unionIndex175)); + } + } + int unionIndex176 = (decoder.readIndex()); + if (unionIndex176 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(176, null); + } else { + if (unionIndex176 == 1) { + Utf8 charSequence176; + Object oldString176 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(176); + if (oldString176 instanceof Utf8) { + charSequence176 = (decoder).readString(((Utf8) oldString176)); + } else { + charSequence176 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(176, charSequence176); + } else { + throw new RuntimeException(("Illegal union index for 'F176': "+ unionIndex176)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex177 = (decoder.readIndex()); + if (unionIndex177 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(177, null); + } else { + if (unionIndex177 == 1) { + Utf8 charSequence177; + Object oldString177 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(177); + if (oldString177 instanceof Utf8) { + charSequence177 = (decoder).readString(((Utf8) oldString177)); + } else { + charSequence177 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(177, charSequence177); + } else { + throw new RuntimeException(("Illegal union index for 'F177': "+ unionIndex177)); + } + } + int unionIndex178 = (decoder.readIndex()); + if (unionIndex178 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(178, null); + } else { + if (unionIndex178 == 1) { + Utf8 charSequence178; + Object oldString178 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(178); + if (oldString178 instanceof Utf8) { + charSequence178 = (decoder).readString(((Utf8) oldString178)); + } else { + charSequence178 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(178, charSequence178); + } else { + throw new RuntimeException(("Illegal union index for 'F178': "+ unionIndex178)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex179 = (decoder.readIndex()); + if (unionIndex179 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(179, null); + } else { + if (unionIndex179 == 1) { + Utf8 charSequence179; + Object oldString179 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(179); + if (oldString179 instanceof Utf8) { + charSequence179 = (decoder).readString(((Utf8) oldString179)); + } else { + charSequence179 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(179, charSequence179); + } else { + throw new RuntimeException(("Illegal union index for 'F179': "+ unionIndex179)); + } + } + int unionIndex180 = (decoder.readIndex()); + if (unionIndex180 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(180, null); + } else { + if (unionIndex180 == 1) { + Utf8 charSequence180; + Object oldString180 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(180); + if (oldString180 instanceof Utf8) { + charSequence180 = (decoder).readString(((Utf8) oldString180)); + } else { + charSequence180 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(180, charSequence180); + } else { + throw new RuntimeException(("Illegal union index for 'F180': "+ unionIndex180)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex181 = (decoder.readIndex()); + if (unionIndex181 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(181, null); + } else { + if (unionIndex181 == 1) { + Utf8 charSequence181; + Object oldString181 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(181); + if (oldString181 instanceof Utf8) { + charSequence181 = (decoder).readString(((Utf8) oldString181)); + } else { + charSequence181 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(181, charSequence181); + } else { + throw new RuntimeException(("Illegal union index for 'F181': "+ unionIndex181)); + } + } + int unionIndex182 = (decoder.readIndex()); + if (unionIndex182 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(182, null); + } else { + if (unionIndex182 == 1) { + Utf8 charSequence182; + Object oldString182 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(182); + if (oldString182 instanceof Utf8) { + charSequence182 = (decoder).readString(((Utf8) oldString182)); + } else { + charSequence182 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(182, charSequence182); + } else { + throw new RuntimeException(("Illegal union index for 'F182': "+ unionIndex182)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex183 = (decoder.readIndex()); + if (unionIndex183 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(183, null); + } else { + if (unionIndex183 == 1) { + Utf8 charSequence183; + Object oldString183 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(183); + if (oldString183 instanceof Utf8) { + charSequence183 = (decoder).readString(((Utf8) oldString183)); + } else { + charSequence183 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(183, charSequence183); + } else { + throw new RuntimeException(("Illegal union index for 'F183': "+ unionIndex183)); + } + } + int unionIndex184 = (decoder.readIndex()); + if (unionIndex184 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(184, null); + } else { + if (unionIndex184 == 1) { + Utf8 charSequence184; + Object oldString184 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(184); + if (oldString184 instanceof Utf8) { + charSequence184 = (decoder).readString(((Utf8) oldString184)); + } else { + charSequence184 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(184, charSequence184); + } else { + throw new RuntimeException(("Illegal union index for 'F184': "+ unionIndex184)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex185 = (decoder.readIndex()); + if (unionIndex185 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(185, null); + } else { + if (unionIndex185 == 1) { + Utf8 charSequence185; + Object oldString185 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(185); + if (oldString185 instanceof Utf8) { + charSequence185 = (decoder).readString(((Utf8) oldString185)); + } else { + charSequence185 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(185, charSequence185); + } else { + throw new RuntimeException(("Illegal union index for 'F185': "+ unionIndex185)); + } + } + int unionIndex186 = (decoder.readIndex()); + if (unionIndex186 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(186, null); + } else { + if (unionIndex186 == 1) { + Utf8 charSequence186; + Object oldString186 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(186); + if (oldString186 instanceof Utf8) { + charSequence186 = (decoder).readString(((Utf8) oldString186)); + } else { + charSequence186 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(186, charSequence186); + } else { + throw new RuntimeException(("Illegal union index for 'F186': "+ unionIndex186)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex187 = (decoder.readIndex()); + if (unionIndex187 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(187, null); + } else { + if (unionIndex187 == 1) { + Utf8 charSequence187; + Object oldString187 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(187); + if (oldString187 instanceof Utf8) { + charSequence187 = (decoder).readString(((Utf8) oldString187)); + } else { + charSequence187 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(187, charSequence187); + } else { + throw new RuntimeException(("Illegal union index for 'F187': "+ unionIndex187)); + } + } + int unionIndex188 = (decoder.readIndex()); + if (unionIndex188 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(188, null); + } else { + if (unionIndex188 == 1) { + Utf8 charSequence188; + Object oldString188 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(188); + if (oldString188 instanceof Utf8) { + charSequence188 = (decoder).readString(((Utf8) oldString188)); + } else { + charSequence188 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(188, charSequence188); + } else { + throw new RuntimeException(("Illegal union index for 'F188': "+ unionIndex188)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex189 = (decoder.readIndex()); + if (unionIndex189 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(189, null); + } else { + if (unionIndex189 == 1) { + Utf8 charSequence189; + Object oldString189 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(189); + if (oldString189 instanceof Utf8) { + charSequence189 = (decoder).readString(((Utf8) oldString189)); + } else { + charSequence189 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(189, charSequence189); + } else { + throw new RuntimeException(("Illegal union index for 'F189': "+ unionIndex189)); + } + } + int unionIndex190 = (decoder.readIndex()); + if (unionIndex190 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(190, null); + } else { + if (unionIndex190 == 1) { + Utf8 charSequence190; + Object oldString190 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(190); + if (oldString190 instanceof Utf8) { + charSequence190 = (decoder).readString(((Utf8) oldString190)); + } else { + charSequence190 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(190, charSequence190); + } else { + throw new RuntimeException(("Illegal union index for 'F190': "+ unionIndex190)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex191 = (decoder.readIndex()); + if (unionIndex191 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(191, null); + } else { + if (unionIndex191 == 1) { + Utf8 charSequence191; + Object oldString191 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(191); + if (oldString191 instanceof Utf8) { + charSequence191 = (decoder).readString(((Utf8) oldString191)); + } else { + charSequence191 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(191, charSequence191); + } else { + throw new RuntimeException(("Illegal union index for 'F191': "+ unionIndex191)); + } + } + int unionIndex192 = (decoder.readIndex()); + if (unionIndex192 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(192, null); + } else { + if (unionIndex192 == 1) { + Utf8 charSequence192; + Object oldString192 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(192); + if (oldString192 instanceof Utf8) { + charSequence192 = (decoder).readString(((Utf8) oldString192)); + } else { + charSequence192 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(192, charSequence192); + } else { + throw new RuntimeException(("Illegal union index for 'F192': "+ unionIndex192)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex193 = (decoder.readIndex()); + if (unionIndex193 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(193, null); + } else { + if (unionIndex193 == 1) { + Utf8 charSequence193; + Object oldString193 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(193); + if (oldString193 instanceof Utf8) { + charSequence193 = (decoder).readString(((Utf8) oldString193)); + } else { + charSequence193 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(193, charSequence193); + } else { + throw new RuntimeException(("Illegal union index for 'F193': "+ unionIndex193)); + } + } + int unionIndex194 = (decoder.readIndex()); + if (unionIndex194 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(194, null); + } else { + if (unionIndex194 == 1) { + Utf8 charSequence194; + Object oldString194 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(194); + if (oldString194 instanceof Utf8) { + charSequence194 = (decoder).readString(((Utf8) oldString194)); + } else { + charSequence194 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(194, charSequence194); + } else { + throw new RuntimeException(("Illegal union index for 'F194': "+ unionIndex194)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex195 = (decoder.readIndex()); + if (unionIndex195 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(195, null); + } else { + if (unionIndex195 == 1) { + Utf8 charSequence195; + Object oldString195 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(195); + if (oldString195 instanceof Utf8) { + charSequence195 = (decoder).readString(((Utf8) oldString195)); + } else { + charSequence195 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(195, charSequence195); + } else { + throw new RuntimeException(("Illegal union index for 'F195': "+ unionIndex195)); + } + } + int unionIndex196 = (decoder.readIndex()); + if (unionIndex196 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(196, null); + } else { + if (unionIndex196 == 1) { + Utf8 charSequence196; + Object oldString196 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(196); + if (oldString196 instanceof Utf8) { + charSequence196 = (decoder).readString(((Utf8) oldString196)); + } else { + charSequence196 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(196, charSequence196); + } else { + throw new RuntimeException(("Illegal union index for 'F196': "+ unionIndex196)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex197 = (decoder.readIndex()); + if (unionIndex197 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(197, null); + } else { + if (unionIndex197 == 1) { + Utf8 charSequence197; + Object oldString197 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(197); + if (oldString197 instanceof Utf8) { + charSequence197 = (decoder).readString(((Utf8) oldString197)); + } else { + charSequence197 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(197, charSequence197); + } else { + throw new RuntimeException(("Illegal union index for 'F197': "+ unionIndex197)); + } + } + int unionIndex198 = (decoder.readIndex()); + if (unionIndex198 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(198, null); + } else { + if (unionIndex198 == 1) { + Utf8 charSequence198; + Object oldString198 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(198); + if (oldString198 instanceof Utf8) { + charSequence198 = (decoder).readString(((Utf8) oldString198)); + } else { + charSequence198 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(198, charSequence198); + } else { + throw new RuntimeException(("Illegal union index for 'F198': "+ unionIndex198)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex199 = (decoder.readIndex()); + if (unionIndex199 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(199, null); + } else { + if (unionIndex199 == 1) { + Utf8 charSequence199; + Object oldString199 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(199); + if (oldString199 instanceof Utf8) { + charSequence199 = (decoder).readString(((Utf8) oldString199)); + } else { + charSequence199 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(199, charSequence199); + } else { + throw new RuntimeException(("Illegal union index for 'F199': "+ unionIndex199)); + } + } + int unionIndex200 = (decoder.readIndex()); + if (unionIndex200 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(200, null); + } else { + if (unionIndex200 == 1) { + Utf8 charSequence200; + Object oldString200 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(200); + if (oldString200 instanceof Utf8) { + charSequence200 = (decoder).readString(((Utf8) oldString200)); + } else { + charSequence200 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(200, charSequence200); + } else { + throw new RuntimeException(("Illegal union index for 'F200': "+ unionIndex200)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex201 = (decoder.readIndex()); + if (unionIndex201 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(201, null); + } else { + if (unionIndex201 == 1) { + Utf8 charSequence201; + Object oldString201 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(201); + if (oldString201 instanceof Utf8) { + charSequence201 = (decoder).readString(((Utf8) oldString201)); + } else { + charSequence201 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(201, charSequence201); + } else { + throw new RuntimeException(("Illegal union index for 'F201': "+ unionIndex201)); + } + } + int unionIndex202 = (decoder.readIndex()); + if (unionIndex202 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(202, null); + } else { + if (unionIndex202 == 1) { + Utf8 charSequence202; + Object oldString202 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(202); + if (oldString202 instanceof Utf8) { + charSequence202 = (decoder).readString(((Utf8) oldString202)); + } else { + charSequence202 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(202, charSequence202); + } else { + throw new RuntimeException(("Illegal union index for 'F202': "+ unionIndex202)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex203 = (decoder.readIndex()); + if (unionIndex203 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(203, null); + } else { + if (unionIndex203 == 1) { + Utf8 charSequence203; + Object oldString203 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(203); + if (oldString203 instanceof Utf8) { + charSequence203 = (decoder).readString(((Utf8) oldString203)); + } else { + charSequence203 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(203, charSequence203); + } else { + throw new RuntimeException(("Illegal union index for 'F203': "+ unionIndex203)); + } + } + int unionIndex204 = (decoder.readIndex()); + if (unionIndex204 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(204, null); + } else { + if (unionIndex204 == 1) { + Utf8 charSequence204; + Object oldString204 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(204); + if (oldString204 instanceof Utf8) { + charSequence204 = (decoder).readString(((Utf8) oldString204)); + } else { + charSequence204 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(204, charSequence204); + } else { + throw new RuntimeException(("Illegal union index for 'F204': "+ unionIndex204)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex205 = (decoder.readIndex()); + if (unionIndex205 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(205, null); + } else { + if (unionIndex205 == 1) { + Utf8 charSequence205; + Object oldString205 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(205); + if (oldString205 instanceof Utf8) { + charSequence205 = (decoder).readString(((Utf8) oldString205)); + } else { + charSequence205 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(205, charSequence205); + } else { + throw new RuntimeException(("Illegal union index for 'F205': "+ unionIndex205)); + } + } + int unionIndex206 = (decoder.readIndex()); + if (unionIndex206 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(206, null); + } else { + if (unionIndex206 == 1) { + Utf8 charSequence206; + Object oldString206 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(206); + if (oldString206 instanceof Utf8) { + charSequence206 = (decoder).readString(((Utf8) oldString206)); + } else { + charSequence206 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(206, charSequence206); + } else { + throw new RuntimeException(("Illegal union index for 'F206': "+ unionIndex206)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex207 = (decoder.readIndex()); + if (unionIndex207 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(207, null); + } else { + if (unionIndex207 == 1) { + Utf8 charSequence207; + Object oldString207 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(207); + if (oldString207 instanceof Utf8) { + charSequence207 = (decoder).readString(((Utf8) oldString207)); + } else { + charSequence207 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(207, charSequence207); + } else { + throw new RuntimeException(("Illegal union index for 'F207': "+ unionIndex207)); + } + } + int unionIndex208 = (decoder.readIndex()); + if (unionIndex208 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(208, null); + } else { + if (unionIndex208 == 1) { + Utf8 charSequence208; + Object oldString208 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(208); + if (oldString208 instanceof Utf8) { + charSequence208 = (decoder).readString(((Utf8) oldString208)); + } else { + charSequence208 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(208, charSequence208); + } else { + throw new RuntimeException(("Illegal union index for 'F208': "+ unionIndex208)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex209 = (decoder.readIndex()); + if (unionIndex209 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(209, null); + } else { + if (unionIndex209 == 1) { + Utf8 charSequence209; + Object oldString209 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(209); + if (oldString209 instanceof Utf8) { + charSequence209 = (decoder).readString(((Utf8) oldString209)); + } else { + charSequence209 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(209, charSequence209); + } else { + throw new RuntimeException(("Illegal union index for 'F209': "+ unionIndex209)); + } + } + int unionIndex210 = (decoder.readIndex()); + if (unionIndex210 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(210, null); + } else { + if (unionIndex210 == 1) { + Utf8 charSequence210; + Object oldString210 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(210); + if (oldString210 instanceof Utf8) { + charSequence210 = (decoder).readString(((Utf8) oldString210)); + } else { + charSequence210 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(210, charSequence210); + } else { + throw new RuntimeException(("Illegal union index for 'F210': "+ unionIndex210)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex211 = (decoder.readIndex()); + if (unionIndex211 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(211, null); + } else { + if (unionIndex211 == 1) { + Utf8 charSequence211; + Object oldString211 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(211); + if (oldString211 instanceof Utf8) { + charSequence211 = (decoder).readString(((Utf8) oldString211)); + } else { + charSequence211 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(211, charSequence211); + } else { + throw new RuntimeException(("Illegal union index for 'F211': "+ unionIndex211)); + } + } + int unionIndex212 = (decoder.readIndex()); + if (unionIndex212 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(212, null); + } else { + if (unionIndex212 == 1) { + Utf8 charSequence212; + Object oldString212 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(212); + if (oldString212 instanceof Utf8) { + charSequence212 = (decoder).readString(((Utf8) oldString212)); + } else { + charSequence212 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(212, charSequence212); + } else { + throw new RuntimeException(("Illegal union index for 'F212': "+ unionIndex212)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex213 = (decoder.readIndex()); + if (unionIndex213 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(213, null); + } else { + if (unionIndex213 == 1) { + Utf8 charSequence213; + Object oldString213 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(213); + if (oldString213 instanceof Utf8) { + charSequence213 = (decoder).readString(((Utf8) oldString213)); + } else { + charSequence213 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(213, charSequence213); + } else { + throw new RuntimeException(("Illegal union index for 'F213': "+ unionIndex213)); + } + } + int unionIndex214 = (decoder.readIndex()); + if (unionIndex214 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(214, null); + } else { + if (unionIndex214 == 1) { + Utf8 charSequence214; + Object oldString214 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(214); + if (oldString214 instanceof Utf8) { + charSequence214 = (decoder).readString(((Utf8) oldString214)); + } else { + charSequence214 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(214, charSequence214); + } else { + throw new RuntimeException(("Illegal union index for 'F214': "+ unionIndex214)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex215 = (decoder.readIndex()); + if (unionIndex215 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(215, null); + } else { + if (unionIndex215 == 1) { + Utf8 charSequence215; + Object oldString215 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(215); + if (oldString215 instanceof Utf8) { + charSequence215 = (decoder).readString(((Utf8) oldString215)); + } else { + charSequence215 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(215, charSequence215); + } else { + throw new RuntimeException(("Illegal union index for 'F215': "+ unionIndex215)); + } + } + int unionIndex216 = (decoder.readIndex()); + if (unionIndex216 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(216, null); + } else { + if (unionIndex216 == 1) { + Utf8 charSequence216; + Object oldString216 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(216); + if (oldString216 instanceof Utf8) { + charSequence216 = (decoder).readString(((Utf8) oldString216)); + } else { + charSequence216 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(216, charSequence216); + } else { + throw new RuntimeException(("Illegal union index for 'F216': "+ unionIndex216)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex217 = (decoder.readIndex()); + if (unionIndex217 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(217, null); + } else { + if (unionIndex217 == 1) { + Utf8 charSequence217; + Object oldString217 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(217); + if (oldString217 instanceof Utf8) { + charSequence217 = (decoder).readString(((Utf8) oldString217)); + } else { + charSequence217 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(217, charSequence217); + } else { + throw new RuntimeException(("Illegal union index for 'F217': "+ unionIndex217)); + } + } + int unionIndex218 = (decoder.readIndex()); + if (unionIndex218 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(218, null); + } else { + if (unionIndex218 == 1) { + Utf8 charSequence218; + Object oldString218 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(218); + if (oldString218 instanceof Utf8) { + charSequence218 = (decoder).readString(((Utf8) oldString218)); + } else { + charSequence218 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(218, charSequence218); + } else { + throw new RuntimeException(("Illegal union index for 'F218': "+ unionIndex218)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex219 = (decoder.readIndex()); + if (unionIndex219 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(219, null); + } else { + if (unionIndex219 == 1) { + Utf8 charSequence219; + Object oldString219 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(219); + if (oldString219 instanceof Utf8) { + charSequence219 = (decoder).readString(((Utf8) oldString219)); + } else { + charSequence219 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(219, charSequence219); + } else { + throw new RuntimeException(("Illegal union index for 'F219': "+ unionIndex219)); + } + } + int unionIndex220 = (decoder.readIndex()); + if (unionIndex220 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(220, null); + } else { + if (unionIndex220 == 1) { + Utf8 charSequence220; + Object oldString220 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(220); + if (oldString220 instanceof Utf8) { + charSequence220 = (decoder).readString(((Utf8) oldString220)); + } else { + charSequence220 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(220, charSequence220); + } else { + throw new RuntimeException(("Illegal union index for 'F220': "+ unionIndex220)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex221 = (decoder.readIndex()); + if (unionIndex221 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(221, null); + } else { + if (unionIndex221 == 1) { + Utf8 charSequence221; + Object oldString221 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(221); + if (oldString221 instanceof Utf8) { + charSequence221 = (decoder).readString(((Utf8) oldString221)); + } else { + charSequence221 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(221, charSequence221); + } else { + throw new RuntimeException(("Illegal union index for 'F221': "+ unionIndex221)); + } + } + int unionIndex222 = (decoder.readIndex()); + if (unionIndex222 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(222, null); + } else { + if (unionIndex222 == 1) { + Utf8 charSequence222; + Object oldString222 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(222); + if (oldString222 instanceof Utf8) { + charSequence222 = (decoder).readString(((Utf8) oldString222)); + } else { + charSequence222 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(222, charSequence222); + } else { + throw new RuntimeException(("Illegal union index for 'F222': "+ unionIndex222)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex223 = (decoder.readIndex()); + if (unionIndex223 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(223, null); + } else { + if (unionIndex223 == 1) { + Utf8 charSequence223; + Object oldString223 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(223); + if (oldString223 instanceof Utf8) { + charSequence223 = (decoder).readString(((Utf8) oldString223)); + } else { + charSequence223 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(223, charSequence223); + } else { + throw new RuntimeException(("Illegal union index for 'F223': "+ unionIndex223)); + } + } + int unionIndex224 = (decoder.readIndex()); + if (unionIndex224 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(224, null); + } else { + if (unionIndex224 == 1) { + Utf8 charSequence224; + Object oldString224 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(224); + if (oldString224 instanceof Utf8) { + charSequence224 = (decoder).readString(((Utf8) oldString224)); + } else { + charSequence224 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(224, charSequence224); + } else { + throw new RuntimeException(("Illegal union index for 'F224': "+ unionIndex224)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex225 = (decoder.readIndex()); + if (unionIndex225 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(225, null); + } else { + if (unionIndex225 == 1) { + Utf8 charSequence225; + Object oldString225 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(225); + if (oldString225 instanceof Utf8) { + charSequence225 = (decoder).readString(((Utf8) oldString225)); + } else { + charSequence225 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(225, charSequence225); + } else { + throw new RuntimeException(("Illegal union index for 'F225': "+ unionIndex225)); + } + } + int unionIndex226 = (decoder.readIndex()); + if (unionIndex226 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(226, null); + } else { + if (unionIndex226 == 1) { + Utf8 charSequence226; + Object oldString226 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(226); + if (oldString226 instanceof Utf8) { + charSequence226 = (decoder).readString(((Utf8) oldString226)); + } else { + charSequence226 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(226, charSequence226); + } else { + throw new RuntimeException(("Illegal union index for 'F226': "+ unionIndex226)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex227 = (decoder.readIndex()); + if (unionIndex227 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(227, null); + } else { + if (unionIndex227 == 1) { + Utf8 charSequence227; + Object oldString227 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(227); + if (oldString227 instanceof Utf8) { + charSequence227 = (decoder).readString(((Utf8) oldString227)); + } else { + charSequence227 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(227, charSequence227); + } else { + throw new RuntimeException(("Illegal union index for 'F227': "+ unionIndex227)); + } + } + int unionIndex228 = (decoder.readIndex()); + if (unionIndex228 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(228, null); + } else { + if (unionIndex228 == 1) { + Utf8 charSequence228; + Object oldString228 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(228); + if (oldString228 instanceof Utf8) { + charSequence228 = (decoder).readString(((Utf8) oldString228)); + } else { + charSequence228 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(228, charSequence228); + } else { + throw new RuntimeException(("Illegal union index for 'F228': "+ unionIndex228)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex229 = (decoder.readIndex()); + if (unionIndex229 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(229, null); + } else { + if (unionIndex229 == 1) { + Utf8 charSequence229; + Object oldString229 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(229); + if (oldString229 instanceof Utf8) { + charSequence229 = (decoder).readString(((Utf8) oldString229)); + } else { + charSequence229 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(229, charSequence229); + } else { + throw new RuntimeException(("Illegal union index for 'F229': "+ unionIndex229)); + } + } + int unionIndex230 = (decoder.readIndex()); + if (unionIndex230 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(230, null); + } else { + if (unionIndex230 == 1) { + Utf8 charSequence230; + Object oldString230 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(230); + if (oldString230 instanceof Utf8) { + charSequence230 = (decoder).readString(((Utf8) oldString230)); + } else { + charSequence230 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(230, charSequence230); + } else { + throw new RuntimeException(("Illegal union index for 'F230': "+ unionIndex230)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex231 = (decoder.readIndex()); + if (unionIndex231 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(231, null); + } else { + if (unionIndex231 == 1) { + Utf8 charSequence231; + Object oldString231 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(231); + if (oldString231 instanceof Utf8) { + charSequence231 = (decoder).readString(((Utf8) oldString231)); + } else { + charSequence231 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(231, charSequence231); + } else { + throw new RuntimeException(("Illegal union index for 'F231': "+ unionIndex231)); + } + } + int unionIndex232 = (decoder.readIndex()); + if (unionIndex232 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(232, null); + } else { + if (unionIndex232 == 1) { + Utf8 charSequence232; + Object oldString232 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(232); + if (oldString232 instanceof Utf8) { + charSequence232 = (decoder).readString(((Utf8) oldString232)); + } else { + charSequence232 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(232, charSequence232); + } else { + throw new RuntimeException(("Illegal union index for 'F232': "+ unionIndex232)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex233 = (decoder.readIndex()); + if (unionIndex233 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(233, null); + } else { + if (unionIndex233 == 1) { + Utf8 charSequence233; + Object oldString233 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(233); + if (oldString233 instanceof Utf8) { + charSequence233 = (decoder).readString(((Utf8) oldString233)); + } else { + charSequence233 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(233, charSequence233); + } else { + throw new RuntimeException(("Illegal union index for 'F233': "+ unionIndex233)); + } + } + int unionIndex234 = (decoder.readIndex()); + if (unionIndex234 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(234, null); + } else { + if (unionIndex234 == 1) { + Utf8 charSequence234; + Object oldString234 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(234); + if (oldString234 instanceof Utf8) { + charSequence234 = (decoder).readString(((Utf8) oldString234)); + } else { + charSequence234 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(234, charSequence234); + } else { + throw new RuntimeException(("Illegal union index for 'F234': "+ unionIndex234)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex235 = (decoder.readIndex()); + if (unionIndex235 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(235, null); + } else { + if (unionIndex235 == 1) { + Utf8 charSequence235; + Object oldString235 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(235); + if (oldString235 instanceof Utf8) { + charSequence235 = (decoder).readString(((Utf8) oldString235)); + } else { + charSequence235 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(235, charSequence235); + } else { + throw new RuntimeException(("Illegal union index for 'F235': "+ unionIndex235)); + } + } + int unionIndex236 = (decoder.readIndex()); + if (unionIndex236 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(236, null); + } else { + if (unionIndex236 == 1) { + Utf8 charSequence236; + Object oldString236 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(236); + if (oldString236 instanceof Utf8) { + charSequence236 = (decoder).readString(((Utf8) oldString236)); + } else { + charSequence236 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(236, charSequence236); + } else { + throw new RuntimeException(("Illegal union index for 'F236': "+ unionIndex236)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex237 = (decoder.readIndex()); + if (unionIndex237 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(237, null); + } else { + if (unionIndex237 == 1) { + Utf8 charSequence237; + Object oldString237 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(237); + if (oldString237 instanceof Utf8) { + charSequence237 = (decoder).readString(((Utf8) oldString237)); + } else { + charSequence237 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(237, charSequence237); + } else { + throw new RuntimeException(("Illegal union index for 'F237': "+ unionIndex237)); + } + } + int unionIndex238 = (decoder.readIndex()); + if (unionIndex238 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(238, null); + } else { + if (unionIndex238 == 1) { + Utf8 charSequence238; + Object oldString238 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(238); + if (oldString238 instanceof Utf8) { + charSequence238 = (decoder).readString(((Utf8) oldString238)); + } else { + charSequence238 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(238, charSequence238); + } else { + throw new RuntimeException(("Illegal union index for 'F238': "+ unionIndex238)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex239 = (decoder.readIndex()); + if (unionIndex239 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(239, null); + } else { + if (unionIndex239 == 1) { + Utf8 charSequence239; + Object oldString239 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(239); + if (oldString239 instanceof Utf8) { + charSequence239 = (decoder).readString(((Utf8) oldString239)); + } else { + charSequence239 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(239, charSequence239); + } else { + throw new RuntimeException(("Illegal union index for 'F239': "+ unionIndex239)); + } + } + int unionIndex240 = (decoder.readIndex()); + if (unionIndex240 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(240, null); + } else { + if (unionIndex240 == 1) { + Utf8 charSequence240; + Object oldString240 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(240); + if (oldString240 instanceof Utf8) { + charSequence240 = (decoder).readString(((Utf8) oldString240)); + } else { + charSequence240 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(240, charSequence240); + } else { + throw new RuntimeException(("Illegal union index for 'F240': "+ unionIndex240)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex241 = (decoder.readIndex()); + if (unionIndex241 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(241, null); + } else { + if (unionIndex241 == 1) { + Utf8 charSequence241; + Object oldString241 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(241); + if (oldString241 instanceof Utf8) { + charSequence241 = (decoder).readString(((Utf8) oldString241)); + } else { + charSequence241 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(241, charSequence241); + } else { + throw new RuntimeException(("Illegal union index for 'F241': "+ unionIndex241)); + } + } + int unionIndex242 = (decoder.readIndex()); + if (unionIndex242 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(242, null); + } else { + if (unionIndex242 == 1) { + Utf8 charSequence242; + Object oldString242 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(242); + if (oldString242 instanceof Utf8) { + charSequence242 = (decoder).readString(((Utf8) oldString242)); + } else { + charSequence242 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(242, charSequence242); + } else { + throw new RuntimeException(("Illegal union index for 'F242': "+ unionIndex242)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex243 = (decoder.readIndex()); + if (unionIndex243 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(243, null); + } else { + if (unionIndex243 == 1) { + Utf8 charSequence243; + Object oldString243 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(243); + if (oldString243 instanceof Utf8) { + charSequence243 = (decoder).readString(((Utf8) oldString243)); + } else { + charSequence243 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(243, charSequence243); + } else { + throw new RuntimeException(("Illegal union index for 'F243': "+ unionIndex243)); + } + } + int unionIndex244 = (decoder.readIndex()); + if (unionIndex244 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(244, null); + } else { + if (unionIndex244 == 1) { + Utf8 charSequence244; + Object oldString244 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(244); + if (oldString244 instanceof Utf8) { + charSequence244 = (decoder).readString(((Utf8) oldString244)); + } else { + charSequence244 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(244, charSequence244); + } else { + throw new RuntimeException(("Illegal union index for 'F244': "+ unionIndex244)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex245 = (decoder.readIndex()); + if (unionIndex245 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(245, null); + } else { + if (unionIndex245 == 1) { + Utf8 charSequence245; + Object oldString245 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(245); + if (oldString245 instanceof Utf8) { + charSequence245 = (decoder).readString(((Utf8) oldString245)); + } else { + charSequence245 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(245, charSequence245); + } else { + throw new RuntimeException(("Illegal union index for 'F245': "+ unionIndex245)); + } + } + int unionIndex246 = (decoder.readIndex()); + if (unionIndex246 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(246, null); + } else { + if (unionIndex246 == 1) { + Utf8 charSequence246; + Object oldString246 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(246); + if (oldString246 instanceof Utf8) { + charSequence246 = (decoder).readString(((Utf8) oldString246)); + } else { + charSequence246 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(246, charSequence246); + } else { + throw new RuntimeException(("Illegal union index for 'F246': "+ unionIndex246)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex247 = (decoder.readIndex()); + if (unionIndex247 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(247, null); + } else { + if (unionIndex247 == 1) { + Utf8 charSequence247; + Object oldString247 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(247); + if (oldString247 instanceof Utf8) { + charSequence247 = (decoder).readString(((Utf8) oldString247)); + } else { + charSequence247 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(247, charSequence247); + } else { + throw new RuntimeException(("Illegal union index for 'F247': "+ unionIndex247)); + } + } + int unionIndex248 = (decoder.readIndex()); + if (unionIndex248 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(248, null); + } else { + if (unionIndex248 == 1) { + Utf8 charSequence248; + Object oldString248 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(248); + if (oldString248 instanceof Utf8) { + charSequence248 = (decoder).readString(((Utf8) oldString248)); + } else { + charSequence248 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(248, charSequence248); + } else { + throw new RuntimeException(("Illegal union index for 'F248': "+ unionIndex248)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex249 = (decoder.readIndex()); + if (unionIndex249 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(249, null); + } else { + if (unionIndex249 == 1) { + Utf8 charSequence249; + Object oldString249 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(249); + if (oldString249 instanceof Utf8) { + charSequence249 = (decoder).readString(((Utf8) oldString249)); + } else { + charSequence249 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(249, charSequence249); + } else { + throw new RuntimeException(("Illegal union index for 'F249': "+ unionIndex249)); + } + } + int unionIndex250 = (decoder.readIndex()); + if (unionIndex250 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(250, null); + } else { + if (unionIndex250 == 1) { + Utf8 charSequence250; + Object oldString250 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(250); + if (oldString250 instanceof Utf8) { + charSequence250 = (decoder).readString(((Utf8) oldString250)); + } else { + charSequence250 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(250, charSequence250); + } else { + throw new RuntimeException(("Illegal union index for 'F250': "+ unionIndex250)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex251 = (decoder.readIndex()); + if (unionIndex251 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(251, null); + } else { + if (unionIndex251 == 1) { + Utf8 charSequence251; + Object oldString251 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(251); + if (oldString251 instanceof Utf8) { + charSequence251 = (decoder).readString(((Utf8) oldString251)); + } else { + charSequence251 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(251, charSequence251); + } else { + throw new RuntimeException(("Illegal union index for 'F251': "+ unionIndex251)); + } + } + int unionIndex252 = (decoder.readIndex()); + if (unionIndex252 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(252, null); + } else { + if (unionIndex252 == 1) { + Utf8 charSequence252; + Object oldString252 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(252); + if (oldString252 instanceof Utf8) { + charSequence252 = (decoder).readString(((Utf8) oldString252)); + } else { + charSequence252 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(252, charSequence252); + } else { + throw new RuntimeException(("Illegal union index for 'F252': "+ unionIndex252)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex253 = (decoder.readIndex()); + if (unionIndex253 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(253, null); + } else { + if (unionIndex253 == 1) { + Utf8 charSequence253; + Object oldString253 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(253); + if (oldString253 instanceof Utf8) { + charSequence253 = (decoder).readString(((Utf8) oldString253)); + } else { + charSequence253 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(253, charSequence253); + } else { + throw new RuntimeException(("Illegal union index for 'F253': "+ unionIndex253)); + } + } + int unionIndex254 = (decoder.readIndex()); + if (unionIndex254 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(254, null); + } else { + if (unionIndex254 == 1) { + Utf8 charSequence254; + Object oldString254 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(254); + if (oldString254 instanceof Utf8) { + charSequence254 = (decoder).readString(((Utf8) oldString254)); + } else { + charSequence254 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(254, charSequence254); + } else { + throw new RuntimeException(("Illegal union index for 'F254': "+ unionIndex254)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex255 = (decoder.readIndex()); + if (unionIndex255 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(255, null); + } else { + if (unionIndex255 == 1) { + Utf8 charSequence255; + Object oldString255 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(255); + if (oldString255 instanceof Utf8) { + charSequence255 = (decoder).readString(((Utf8) oldString255)); + } else { + charSequence255 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(255, charSequence255); + } else { + throw new RuntimeException(("Illegal union index for 'F255': "+ unionIndex255)); + } + } + int unionIndex256 = (decoder.readIndex()); + if (unionIndex256 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(256, null); + } else { + if (unionIndex256 == 1) { + Utf8 charSequence256; + Object oldString256 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(256); + if (oldString256 instanceof Utf8) { + charSequence256 = (decoder).readString(((Utf8) oldString256)); + } else { + charSequence256 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(256, charSequence256); + } else { + throw new RuntimeException(("Illegal union index for 'F256': "+ unionIndex256)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex257 = (decoder.readIndex()); + if (unionIndex257 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(257, null); + } else { + if (unionIndex257 == 1) { + Utf8 charSequence257; + Object oldString257 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(257); + if (oldString257 instanceof Utf8) { + charSequence257 = (decoder).readString(((Utf8) oldString257)); + } else { + charSequence257 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(257, charSequence257); + } else { + throw new RuntimeException(("Illegal union index for 'F257': "+ unionIndex257)); + } + } + int unionIndex258 = (decoder.readIndex()); + if (unionIndex258 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(258, null); + } else { + if (unionIndex258 == 1) { + Utf8 charSequence258; + Object oldString258 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(258); + if (oldString258 instanceof Utf8) { + charSequence258 = (decoder).readString(((Utf8) oldString258)); + } else { + charSequence258 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(258, charSequence258); + } else { + throw new RuntimeException(("Illegal union index for 'F258': "+ unionIndex258)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex259 = (decoder.readIndex()); + if (unionIndex259 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(259, null); + } else { + if (unionIndex259 == 1) { + Utf8 charSequence259; + Object oldString259 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(259); + if (oldString259 instanceof Utf8) { + charSequence259 = (decoder).readString(((Utf8) oldString259)); + } else { + charSequence259 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(259, charSequence259); + } else { + throw new RuntimeException(("Illegal union index for 'F259': "+ unionIndex259)); + } + } + int unionIndex260 = (decoder.readIndex()); + if (unionIndex260 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(260, null); + } else { + if (unionIndex260 == 1) { + Utf8 charSequence260; + Object oldString260 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(260); + if (oldString260 instanceof Utf8) { + charSequence260 = (decoder).readString(((Utf8) oldString260)); + } else { + charSequence260 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(260, charSequence260); + } else { + throw new RuntimeException(("Illegal union index for 'F260': "+ unionIndex260)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex261 = (decoder.readIndex()); + if (unionIndex261 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(261, null); + } else { + if (unionIndex261 == 1) { + Utf8 charSequence261; + Object oldString261 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(261); + if (oldString261 instanceof Utf8) { + charSequence261 = (decoder).readString(((Utf8) oldString261)); + } else { + charSequence261 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(261, charSequence261); + } else { + throw new RuntimeException(("Illegal union index for 'F261': "+ unionIndex261)); + } + } + int unionIndex262 = (decoder.readIndex()); + if (unionIndex262 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(262, null); + } else { + if (unionIndex262 == 1) { + Utf8 charSequence262; + Object oldString262 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(262); + if (oldString262 instanceof Utf8) { + charSequence262 = (decoder).readString(((Utf8) oldString262)); + } else { + charSequence262 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(262, charSequence262); + } else { + throw new RuntimeException(("Illegal union index for 'F262': "+ unionIndex262)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex263 = (decoder.readIndex()); + if (unionIndex263 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(263, null); + } else { + if (unionIndex263 == 1) { + Utf8 charSequence263; + Object oldString263 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(263); + if (oldString263 instanceof Utf8) { + charSequence263 = (decoder).readString(((Utf8) oldString263)); + } else { + charSequence263 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(263, charSequence263); + } else { + throw new RuntimeException(("Illegal union index for 'F263': "+ unionIndex263)); + } + } + int unionIndex264 = (decoder.readIndex()); + if (unionIndex264 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(264, null); + } else { + if (unionIndex264 == 1) { + Utf8 charSequence264; + Object oldString264 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(264); + if (oldString264 instanceof Utf8) { + charSequence264 = (decoder).readString(((Utf8) oldString264)); + } else { + charSequence264 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(264, charSequence264); + } else { + throw new RuntimeException(("Illegal union index for 'F264': "+ unionIndex264)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex265 = (decoder.readIndex()); + if (unionIndex265 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(265, null); + } else { + if (unionIndex265 == 1) { + Utf8 charSequence265; + Object oldString265 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(265); + if (oldString265 instanceof Utf8) { + charSequence265 = (decoder).readString(((Utf8) oldString265)); + } else { + charSequence265 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(265, charSequence265); + } else { + throw new RuntimeException(("Illegal union index for 'F265': "+ unionIndex265)); + } + } + int unionIndex266 = (decoder.readIndex()); + if (unionIndex266 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(266, null); + } else { + if (unionIndex266 == 1) { + Utf8 charSequence266; + Object oldString266 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(266); + if (oldString266 instanceof Utf8) { + charSequence266 = (decoder).readString(((Utf8) oldString266)); + } else { + charSequence266 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(266, charSequence266); + } else { + throw new RuntimeException(("Illegal union index for 'F266': "+ unionIndex266)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex267 = (decoder.readIndex()); + if (unionIndex267 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(267, null); + } else { + if (unionIndex267 == 1) { + Utf8 charSequence267; + Object oldString267 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(267); + if (oldString267 instanceof Utf8) { + charSequence267 = (decoder).readString(((Utf8) oldString267)); + } else { + charSequence267 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(267, charSequence267); + } else { + throw new RuntimeException(("Illegal union index for 'F267': "+ unionIndex267)); + } + } + int unionIndex268 = (decoder.readIndex()); + if (unionIndex268 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(268, null); + } else { + if (unionIndex268 == 1) { + Utf8 charSequence268; + Object oldString268 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(268); + if (oldString268 instanceof Utf8) { + charSequence268 = (decoder).readString(((Utf8) oldString268)); + } else { + charSequence268 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(268, charSequence268); + } else { + throw new RuntimeException(("Illegal union index for 'F268': "+ unionIndex268)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex269 = (decoder.readIndex()); + if (unionIndex269 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(269, null); + } else { + if (unionIndex269 == 1) { + Utf8 charSequence269; + Object oldString269 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(269); + if (oldString269 instanceof Utf8) { + charSequence269 = (decoder).readString(((Utf8) oldString269)); + } else { + charSequence269 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(269, charSequence269); + } else { + throw new RuntimeException(("Illegal union index for 'F269': "+ unionIndex269)); + } + } + int unionIndex270 = (decoder.readIndex()); + if (unionIndex270 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(270, null); + } else { + if (unionIndex270 == 1) { + Utf8 charSequence270; + Object oldString270 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(270); + if (oldString270 instanceof Utf8) { + charSequence270 = (decoder).readString(((Utf8) oldString270)); + } else { + charSequence270 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(270, charSequence270); + } else { + throw new RuntimeException(("Illegal union index for 'F270': "+ unionIndex270)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex271 = (decoder.readIndex()); + if (unionIndex271 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(271, null); + } else { + if (unionIndex271 == 1) { + Utf8 charSequence271; + Object oldString271 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(271); + if (oldString271 instanceof Utf8) { + charSequence271 = (decoder).readString(((Utf8) oldString271)); + } else { + charSequence271 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(271, charSequence271); + } else { + throw new RuntimeException(("Illegal union index for 'F271': "+ unionIndex271)); + } + } + int unionIndex272 = (decoder.readIndex()); + if (unionIndex272 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(272, null); + } else { + if (unionIndex272 == 1) { + Utf8 charSequence272; + Object oldString272 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(272); + if (oldString272 instanceof Utf8) { + charSequence272 = (decoder).readString(((Utf8) oldString272)); + } else { + charSequence272 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(272, charSequence272); + } else { + throw new RuntimeException(("Illegal union index for 'F272': "+ unionIndex272)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex273 = (decoder.readIndex()); + if (unionIndex273 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(273, null); + } else { + if (unionIndex273 == 1) { + Utf8 charSequence273; + Object oldString273 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(273); + if (oldString273 instanceof Utf8) { + charSequence273 = (decoder).readString(((Utf8) oldString273)); + } else { + charSequence273 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(273, charSequence273); + } else { + throw new RuntimeException(("Illegal union index for 'F273': "+ unionIndex273)); + } + } + int unionIndex274 = (decoder.readIndex()); + if (unionIndex274 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(274, null); + } else { + if (unionIndex274 == 1) { + Utf8 charSequence274; + Object oldString274 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(274); + if (oldString274 instanceof Utf8) { + charSequence274 = (decoder).readString(((Utf8) oldString274)); + } else { + charSequence274 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(274, charSequence274); + } else { + throw new RuntimeException(("Illegal union index for 'F274': "+ unionIndex274)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex275 = (decoder.readIndex()); + if (unionIndex275 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(275, null); + } else { + if (unionIndex275 == 1) { + Utf8 charSequence275; + Object oldString275 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(275); + if (oldString275 instanceof Utf8) { + charSequence275 = (decoder).readString(((Utf8) oldString275)); + } else { + charSequence275 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(275, charSequence275); + } else { + throw new RuntimeException(("Illegal union index for 'F275': "+ unionIndex275)); + } + } + int unionIndex276 = (decoder.readIndex()); + if (unionIndex276 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(276, null); + } else { + if (unionIndex276 == 1) { + Utf8 charSequence276; + Object oldString276 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(276); + if (oldString276 instanceof Utf8) { + charSequence276 = (decoder).readString(((Utf8) oldString276)); + } else { + charSequence276 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(276, charSequence276); + } else { + throw new RuntimeException(("Illegal union index for 'F276': "+ unionIndex276)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex277 = (decoder.readIndex()); + if (unionIndex277 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(277, null); + } else { + if (unionIndex277 == 1) { + Utf8 charSequence277; + Object oldString277 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(277); + if (oldString277 instanceof Utf8) { + charSequence277 = (decoder).readString(((Utf8) oldString277)); + } else { + charSequence277 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(277, charSequence277); + } else { + throw new RuntimeException(("Illegal union index for 'F277': "+ unionIndex277)); + } + } + int unionIndex278 = (decoder.readIndex()); + if (unionIndex278 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(278, null); + } else { + if (unionIndex278 == 1) { + Utf8 charSequence278; + Object oldString278 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(278); + if (oldString278 instanceof Utf8) { + charSequence278 = (decoder).readString(((Utf8) oldString278)); + } else { + charSequence278 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(278, charSequence278); + } else { + throw new RuntimeException(("Illegal union index for 'F278': "+ unionIndex278)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex279 = (decoder.readIndex()); + if (unionIndex279 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(279, null); + } else { + if (unionIndex279 == 1) { + Utf8 charSequence279; + Object oldString279 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(279); + if (oldString279 instanceof Utf8) { + charSequence279 = (decoder).readString(((Utf8) oldString279)); + } else { + charSequence279 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(279, charSequence279); + } else { + throw new RuntimeException(("Illegal union index for 'F279': "+ unionIndex279)); + } + } + int unionIndex280 = (decoder.readIndex()); + if (unionIndex280 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(280, null); + } else { + if (unionIndex280 == 1) { + Utf8 charSequence280; + Object oldString280 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(280); + if (oldString280 instanceof Utf8) { + charSequence280 = (decoder).readString(((Utf8) oldString280)); + } else { + charSequence280 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(280, charSequence280); + } else { + throw new RuntimeException(("Illegal union index for 'F280': "+ unionIndex280)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex281 = (decoder.readIndex()); + if (unionIndex281 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(281, null); + } else { + if (unionIndex281 == 1) { + Utf8 charSequence281; + Object oldString281 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(281); + if (oldString281 instanceof Utf8) { + charSequence281 = (decoder).readString(((Utf8) oldString281)); + } else { + charSequence281 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(281, charSequence281); + } else { + throw new RuntimeException(("Illegal union index for 'F281': "+ unionIndex281)); + } + } + int unionIndex282 = (decoder.readIndex()); + if (unionIndex282 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(282, null); + } else { + if (unionIndex282 == 1) { + Utf8 charSequence282; + Object oldString282 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(282); + if (oldString282 instanceof Utf8) { + charSequence282 = (decoder).readString(((Utf8) oldString282)); + } else { + charSequence282 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(282, charSequence282); + } else { + throw new RuntimeException(("Illegal union index for 'F282': "+ unionIndex282)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex283 = (decoder.readIndex()); + if (unionIndex283 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(283, null); + } else { + if (unionIndex283 == 1) { + Utf8 charSequence283; + Object oldString283 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(283); + if (oldString283 instanceof Utf8) { + charSequence283 = (decoder).readString(((Utf8) oldString283)); + } else { + charSequence283 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(283, charSequence283); + } else { + throw new RuntimeException(("Illegal union index for 'F283': "+ unionIndex283)); + } + } + int unionIndex284 = (decoder.readIndex()); + if (unionIndex284 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(284, null); + } else { + if (unionIndex284 == 1) { + Utf8 charSequence284; + Object oldString284 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(284); + if (oldString284 instanceof Utf8) { + charSequence284 = (decoder).readString(((Utf8) oldString284)); + } else { + charSequence284 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(284, charSequence284); + } else { + throw new RuntimeException(("Illegal union index for 'F284': "+ unionIndex284)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex285 = (decoder.readIndex()); + if (unionIndex285 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(285, null); + } else { + if (unionIndex285 == 1) { + Utf8 charSequence285; + Object oldString285 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(285); + if (oldString285 instanceof Utf8) { + charSequence285 = (decoder).readString(((Utf8) oldString285)); + } else { + charSequence285 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(285, charSequence285); + } else { + throw new RuntimeException(("Illegal union index for 'F285': "+ unionIndex285)); + } + } + int unionIndex286 = (decoder.readIndex()); + if (unionIndex286 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(286, null); + } else { + if (unionIndex286 == 1) { + Utf8 charSequence286; + Object oldString286 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(286); + if (oldString286 instanceof Utf8) { + charSequence286 = (decoder).readString(((Utf8) oldString286)); + } else { + charSequence286 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(286, charSequence286); + } else { + throw new RuntimeException(("Illegal union index for 'F286': "+ unionIndex286)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex287 = (decoder.readIndex()); + if (unionIndex287 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(287, null); + } else { + if (unionIndex287 == 1) { + Utf8 charSequence287; + Object oldString287 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(287); + if (oldString287 instanceof Utf8) { + charSequence287 = (decoder).readString(((Utf8) oldString287)); + } else { + charSequence287 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(287, charSequence287); + } else { + throw new RuntimeException(("Illegal union index for 'F287': "+ unionIndex287)); + } + } + int unionIndex288 = (decoder.readIndex()); + if (unionIndex288 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(288, null); + } else { + if (unionIndex288 == 1) { + Utf8 charSequence288; + Object oldString288 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(288); + if (oldString288 instanceof Utf8) { + charSequence288 = (decoder).readString(((Utf8) oldString288)); + } else { + charSequence288 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(288, charSequence288); + } else { + throw new RuntimeException(("Illegal union index for 'F288': "+ unionIndex288)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex289 = (decoder.readIndex()); + if (unionIndex289 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(289, null); + } else { + if (unionIndex289 == 1) { + Utf8 charSequence289; + Object oldString289 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(289); + if (oldString289 instanceof Utf8) { + charSequence289 = (decoder).readString(((Utf8) oldString289)); + } else { + charSequence289 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(289, charSequence289); + } else { + throw new RuntimeException(("Illegal union index for 'F289': "+ unionIndex289)); + } + } + int unionIndex290 = (decoder.readIndex()); + if (unionIndex290 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(290, null); + } else { + if (unionIndex290 == 1) { + Utf8 charSequence290; + Object oldString290 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(290); + if (oldString290 instanceof Utf8) { + charSequence290 = (decoder).readString(((Utf8) oldString290)); + } else { + charSequence290 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(290, charSequence290); + } else { + throw new RuntimeException(("Illegal union index for 'F290': "+ unionIndex290)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex291 = (decoder.readIndex()); + if (unionIndex291 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(291, null); + } else { + if (unionIndex291 == 1) { + Utf8 charSequence291; + Object oldString291 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(291); + if (oldString291 instanceof Utf8) { + charSequence291 = (decoder).readString(((Utf8) oldString291)); + } else { + charSequence291 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(291, charSequence291); + } else { + throw new RuntimeException(("Illegal union index for 'F291': "+ unionIndex291)); + } + } + int unionIndex292 = (decoder.readIndex()); + if (unionIndex292 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(292, null); + } else { + if (unionIndex292 == 1) { + Utf8 charSequence292; + Object oldString292 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(292); + if (oldString292 instanceof Utf8) { + charSequence292 = (decoder).readString(((Utf8) oldString292)); + } else { + charSequence292 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(292, charSequence292); + } else { + throw new RuntimeException(("Illegal union index for 'F292': "+ unionIndex292)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex293 = (decoder.readIndex()); + if (unionIndex293 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(293, null); + } else { + if (unionIndex293 == 1) { + Utf8 charSequence293; + Object oldString293 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(293); + if (oldString293 instanceof Utf8) { + charSequence293 = (decoder).readString(((Utf8) oldString293)); + } else { + charSequence293 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(293, charSequence293); + } else { + throw new RuntimeException(("Illegal union index for 'F293': "+ unionIndex293)); + } + } + int unionIndex294 = (decoder.readIndex()); + if (unionIndex294 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(294, null); + } else { + if (unionIndex294 == 1) { + Utf8 charSequence294; + Object oldString294 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(294); + if (oldString294 instanceof Utf8) { + charSequence294 = (decoder).readString(((Utf8) oldString294)); + } else { + charSequence294 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(294, charSequence294); + } else { + throw new RuntimeException(("Illegal union index for 'F294': "+ unionIndex294)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex295 = (decoder.readIndex()); + if (unionIndex295 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(295, null); + } else { + if (unionIndex295 == 1) { + Utf8 charSequence295; + Object oldString295 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(295); + if (oldString295 instanceof Utf8) { + charSequence295 = (decoder).readString(((Utf8) oldString295)); + } else { + charSequence295 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(295, charSequence295); + } else { + throw new RuntimeException(("Illegal union index for 'F295': "+ unionIndex295)); + } + } + int unionIndex296 = (decoder.readIndex()); + if (unionIndex296 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(296, null); + } else { + if (unionIndex296 == 1) { + Utf8 charSequence296; + Object oldString296 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(296); + if (oldString296 instanceof Utf8) { + charSequence296 = (decoder).readString(((Utf8) oldString296)); + } else { + charSequence296 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(296, charSequence296); + } else { + throw new RuntimeException(("Illegal union index for 'F296': "+ unionIndex296)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex297 = (decoder.readIndex()); + if (unionIndex297 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(297, null); + } else { + if (unionIndex297 == 1) { + Utf8 charSequence297; + Object oldString297 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(297); + if (oldString297 instanceof Utf8) { + charSequence297 = (decoder).readString(((Utf8) oldString297)); + } else { + charSequence297 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(297, charSequence297); + } else { + throw new RuntimeException(("Illegal union index for 'F297': "+ unionIndex297)); + } + } + int unionIndex298 = (decoder.readIndex()); + if (unionIndex298 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(298, null); + } else { + if (unionIndex298 == 1) { + Utf8 charSequence298; + Object oldString298 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(298); + if (oldString298 instanceof Utf8) { + charSequence298 = (decoder).readString(((Utf8) oldString298)); + } else { + charSequence298 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(298, charSequence298); + } else { + throw new RuntimeException(("Illegal union index for 'F298': "+ unionIndex298)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex299 = (decoder.readIndex()); + if (unionIndex299 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(299, null); + } else { + if (unionIndex299 == 1) { + Utf8 charSequence299; + Object oldString299 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(299); + if (oldString299 instanceof Utf8) { + charSequence299 = (decoder).readString(((Utf8) oldString299)); + } else { + charSequence299 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(299, charSequence299); + } else { + throw new RuntimeException(("Illegal union index for 'F299': "+ unionIndex299)); + } + } + int unionIndex300 = (decoder.readIndex()); + if (unionIndex300 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(300, null); + } else { + if (unionIndex300 == 1) { + Utf8 charSequence300; + Object oldString300 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(300); + if (oldString300 instanceof Utf8) { + charSequence300 = (decoder).readString(((Utf8) oldString300)); + } else { + charSequence300 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(300, charSequence300); + } else { + throw new RuntimeException(("Illegal union index for 'F300': "+ unionIndex300)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex301 = (decoder.readIndex()); + if (unionIndex301 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(301, null); + } else { + if (unionIndex301 == 1) { + Utf8 charSequence301; + Object oldString301 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(301); + if (oldString301 instanceof Utf8) { + charSequence301 = (decoder).readString(((Utf8) oldString301)); + } else { + charSequence301 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(301, charSequence301); + } else { + throw new RuntimeException(("Illegal union index for 'F301': "+ unionIndex301)); + } + } + int unionIndex302 = (decoder.readIndex()); + if (unionIndex302 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(302, null); + } else { + if (unionIndex302 == 1) { + Utf8 charSequence302; + Object oldString302 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(302); + if (oldString302 instanceof Utf8) { + charSequence302 = (decoder).readString(((Utf8) oldString302)); + } else { + charSequence302 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(302, charSequence302); + } else { + throw new RuntimeException(("Illegal union index for 'F302': "+ unionIndex302)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex303 = (decoder.readIndex()); + if (unionIndex303 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(303, null); + } else { + if (unionIndex303 == 1) { + Utf8 charSequence303; + Object oldString303 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(303); + if (oldString303 instanceof Utf8) { + charSequence303 = (decoder).readString(((Utf8) oldString303)); + } else { + charSequence303 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(303, charSequence303); + } else { + throw new RuntimeException(("Illegal union index for 'F303': "+ unionIndex303)); + } + } + int unionIndex304 = (decoder.readIndex()); + if (unionIndex304 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(304, null); + } else { + if (unionIndex304 == 1) { + Utf8 charSequence304; + Object oldString304 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(304); + if (oldString304 instanceof Utf8) { + charSequence304 = (decoder).readString(((Utf8) oldString304)); + } else { + charSequence304 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(304, charSequence304); + } else { + throw new RuntimeException(("Illegal union index for 'F304': "+ unionIndex304)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex305 = (decoder.readIndex()); + if (unionIndex305 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(305, null); + } else { + if (unionIndex305 == 1) { + Utf8 charSequence305; + Object oldString305 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(305); + if (oldString305 instanceof Utf8) { + charSequence305 = (decoder).readString(((Utf8) oldString305)); + } else { + charSequence305 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(305, charSequence305); + } else { + throw new RuntimeException(("Illegal union index for 'F305': "+ unionIndex305)); + } + } + int unionIndex306 = (decoder.readIndex()); + if (unionIndex306 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(306, null); + } else { + if (unionIndex306 == 1) { + Utf8 charSequence306; + Object oldString306 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(306); + if (oldString306 instanceof Utf8) { + charSequence306 = (decoder).readString(((Utf8) oldString306)); + } else { + charSequence306 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(306, charSequence306); + } else { + throw new RuntimeException(("Illegal union index for 'F306': "+ unionIndex306)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex307 = (decoder.readIndex()); + if (unionIndex307 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(307, null); + } else { + if (unionIndex307 == 1) { + Utf8 charSequence307; + Object oldString307 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(307); + if (oldString307 instanceof Utf8) { + charSequence307 = (decoder).readString(((Utf8) oldString307)); + } else { + charSequence307 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(307, charSequence307); + } else { + throw new RuntimeException(("Illegal union index for 'F307': "+ unionIndex307)); + } + } + int unionIndex308 = (decoder.readIndex()); + if (unionIndex308 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(308, null); + } else { + if (unionIndex308 == 1) { + Utf8 charSequence308; + Object oldString308 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(308); + if (oldString308 instanceof Utf8) { + charSequence308 = (decoder).readString(((Utf8) oldString308)); + } else { + charSequence308 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(308, charSequence308); + } else { + throw new RuntimeException(("Illegal union index for 'F308': "+ unionIndex308)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex309 = (decoder.readIndex()); + if (unionIndex309 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(309, null); + } else { + if (unionIndex309 == 1) { + Utf8 charSequence309; + Object oldString309 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(309); + if (oldString309 instanceof Utf8) { + charSequence309 = (decoder).readString(((Utf8) oldString309)); + } else { + charSequence309 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(309, charSequence309); + } else { + throw new RuntimeException(("Illegal union index for 'F309': "+ unionIndex309)); + } + } + int unionIndex310 = (decoder.readIndex()); + if (unionIndex310 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(310, null); + } else { + if (unionIndex310 == 1) { + Utf8 charSequence310; + Object oldString310 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(310); + if (oldString310 instanceof Utf8) { + charSequence310 = (decoder).readString(((Utf8) oldString310)); + } else { + charSequence310 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(310, charSequence310); + } else { + throw new RuntimeException(("Illegal union index for 'F310': "+ unionIndex310)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex311 = (decoder.readIndex()); + if (unionIndex311 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(311, null); + } else { + if (unionIndex311 == 1) { + Utf8 charSequence311; + Object oldString311 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(311); + if (oldString311 instanceof Utf8) { + charSequence311 = (decoder).readString(((Utf8) oldString311)); + } else { + charSequence311 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(311, charSequence311); + } else { + throw new RuntimeException(("Illegal union index for 'F311': "+ unionIndex311)); + } + } + int unionIndex312 = (decoder.readIndex()); + if (unionIndex312 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(312, null); + } else { + if (unionIndex312 == 1) { + Utf8 charSequence312; + Object oldString312 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(312); + if (oldString312 instanceof Utf8) { + charSequence312 = (decoder).readString(((Utf8) oldString312)); + } else { + charSequence312 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(312, charSequence312); + } else { + throw new RuntimeException(("Illegal union index for 'F312': "+ unionIndex312)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex313 = (decoder.readIndex()); + if (unionIndex313 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(313, null); + } else { + if (unionIndex313 == 1) { + Utf8 charSequence313; + Object oldString313 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(313); + if (oldString313 instanceof Utf8) { + charSequence313 = (decoder).readString(((Utf8) oldString313)); + } else { + charSequence313 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(313, charSequence313); + } else { + throw new RuntimeException(("Illegal union index for 'F313': "+ unionIndex313)); + } + } + int unionIndex314 = (decoder.readIndex()); + if (unionIndex314 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(314, null); + } else { + if (unionIndex314 == 1) { + Utf8 charSequence314; + Object oldString314 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(314); + if (oldString314 instanceof Utf8) { + charSequence314 = (decoder).readString(((Utf8) oldString314)); + } else { + charSequence314 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(314, charSequence314); + } else { + throw new RuntimeException(("Illegal union index for 'F314': "+ unionIndex314)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex315 = (decoder.readIndex()); + if (unionIndex315 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(315, null); + } else { + if (unionIndex315 == 1) { + Utf8 charSequence315; + Object oldString315 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(315); + if (oldString315 instanceof Utf8) { + charSequence315 = (decoder).readString(((Utf8) oldString315)); + } else { + charSequence315 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(315, charSequence315); + } else { + throw new RuntimeException(("Illegal union index for 'F315': "+ unionIndex315)); + } + } + int unionIndex316 = (decoder.readIndex()); + if (unionIndex316 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(316, null); + } else { + if (unionIndex316 == 1) { + Utf8 charSequence316; + Object oldString316 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(316); + if (oldString316 instanceof Utf8) { + charSequence316 = (decoder).readString(((Utf8) oldString316)); + } else { + charSequence316 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(316, charSequence316); + } else { + throw new RuntimeException(("Illegal union index for 'F316': "+ unionIndex316)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex317 = (decoder.readIndex()); + if (unionIndex317 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(317, null); + } else { + if (unionIndex317 == 1) { + Utf8 charSequence317; + Object oldString317 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(317); + if (oldString317 instanceof Utf8) { + charSequence317 = (decoder).readString(((Utf8) oldString317)); + } else { + charSequence317 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(317, charSequence317); + } else { + throw new RuntimeException(("Illegal union index for 'F317': "+ unionIndex317)); + } + } + int unionIndex318 = (decoder.readIndex()); + if (unionIndex318 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(318, null); + } else { + if (unionIndex318 == 1) { + Utf8 charSequence318; + Object oldString318 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(318); + if (oldString318 instanceof Utf8) { + charSequence318 = (decoder).readString(((Utf8) oldString318)); + } else { + charSequence318 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(318, charSequence318); + } else { + throw new RuntimeException(("Illegal union index for 'F318': "+ unionIndex318)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex319 = (decoder.readIndex()); + if (unionIndex319 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(319, null); + } else { + if (unionIndex319 == 1) { + Utf8 charSequence319; + Object oldString319 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(319); + if (oldString319 instanceof Utf8) { + charSequence319 = (decoder).readString(((Utf8) oldString319)); + } else { + charSequence319 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(319, charSequence319); + } else { + throw new RuntimeException(("Illegal union index for 'F319': "+ unionIndex319)); + } + } + int unionIndex320 = (decoder.readIndex()); + if (unionIndex320 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(320, null); + } else { + if (unionIndex320 == 1) { + Utf8 charSequence320; + Object oldString320 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(320); + if (oldString320 instanceof Utf8) { + charSequence320 = (decoder).readString(((Utf8) oldString320)); + } else { + charSequence320 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(320, charSequence320); + } else { + throw new RuntimeException(("Illegal union index for 'F320': "+ unionIndex320)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex321 = (decoder.readIndex()); + if (unionIndex321 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(321, null); + } else { + if (unionIndex321 == 1) { + Utf8 charSequence321; + Object oldString321 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(321); + if (oldString321 instanceof Utf8) { + charSequence321 = (decoder).readString(((Utf8) oldString321)); + } else { + charSequence321 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(321, charSequence321); + } else { + throw new RuntimeException(("Illegal union index for 'F321': "+ unionIndex321)); + } + } + int unionIndex322 = (decoder.readIndex()); + if (unionIndex322 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(322, null); + } else { + if (unionIndex322 == 1) { + Utf8 charSequence322; + Object oldString322 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(322); + if (oldString322 instanceof Utf8) { + charSequence322 = (decoder).readString(((Utf8) oldString322)); + } else { + charSequence322 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(322, charSequence322); + } else { + throw new RuntimeException(("Illegal union index for 'F322': "+ unionIndex322)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex323 = (decoder.readIndex()); + if (unionIndex323 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(323, null); + } else { + if (unionIndex323 == 1) { + Utf8 charSequence323; + Object oldString323 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(323); + if (oldString323 instanceof Utf8) { + charSequence323 = (decoder).readString(((Utf8) oldString323)); + } else { + charSequence323 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(323, charSequence323); + } else { + throw new RuntimeException(("Illegal union index for 'F323': "+ unionIndex323)); + } + } + int unionIndex324 = (decoder.readIndex()); + if (unionIndex324 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(324, null); + } else { + if (unionIndex324 == 1) { + Utf8 charSequence324; + Object oldString324 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(324); + if (oldString324 instanceof Utf8) { + charSequence324 = (decoder).readString(((Utf8) oldString324)); + } else { + charSequence324 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(324, charSequence324); + } else { + throw new RuntimeException(("Illegal union index for 'F324': "+ unionIndex324)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex325 = (decoder.readIndex()); + if (unionIndex325 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(325, null); + } else { + if (unionIndex325 == 1) { + Utf8 charSequence325; + Object oldString325 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(325); + if (oldString325 instanceof Utf8) { + charSequence325 = (decoder).readString(((Utf8) oldString325)); + } else { + charSequence325 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(325, charSequence325); + } else { + throw new RuntimeException(("Illegal union index for 'F325': "+ unionIndex325)); + } + } + int unionIndex326 = (decoder.readIndex()); + if (unionIndex326 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(326, null); + } else { + if (unionIndex326 == 1) { + Utf8 charSequence326; + Object oldString326 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(326); + if (oldString326 instanceof Utf8) { + charSequence326 = (decoder).readString(((Utf8) oldString326)); + } else { + charSequence326 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(326, charSequence326); + } else { + throw new RuntimeException(("Illegal union index for 'F326': "+ unionIndex326)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex327 = (decoder.readIndex()); + if (unionIndex327 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(327, null); + } else { + if (unionIndex327 == 1) { + Utf8 charSequence327; + Object oldString327 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(327); + if (oldString327 instanceof Utf8) { + charSequence327 = (decoder).readString(((Utf8) oldString327)); + } else { + charSequence327 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(327, charSequence327); + } else { + throw new RuntimeException(("Illegal union index for 'F327': "+ unionIndex327)); + } + } + int unionIndex328 = (decoder.readIndex()); + if (unionIndex328 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(328, null); + } else { + if (unionIndex328 == 1) { + Utf8 charSequence328; + Object oldString328 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(328); + if (oldString328 instanceof Utf8) { + charSequence328 = (decoder).readString(((Utf8) oldString328)); + } else { + charSequence328 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(328, charSequence328); + } else { + throw new RuntimeException(("Illegal union index for 'F328': "+ unionIndex328)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex329 = (decoder.readIndex()); + if (unionIndex329 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(329, null); + } else { + if (unionIndex329 == 1) { + Utf8 charSequence329; + Object oldString329 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(329); + if (oldString329 instanceof Utf8) { + charSequence329 = (decoder).readString(((Utf8) oldString329)); + } else { + charSequence329 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(329, charSequence329); + } else { + throw new RuntimeException(("Illegal union index for 'F329': "+ unionIndex329)); + } + } + int unionIndex330 = (decoder.readIndex()); + if (unionIndex330 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(330, null); + } else { + if (unionIndex330 == 1) { + Utf8 charSequence330; + Object oldString330 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(330); + if (oldString330 instanceof Utf8) { + charSequence330 = (decoder).readString(((Utf8) oldString330)); + } else { + charSequence330 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(330, charSequence330); + } else { + throw new RuntimeException(("Illegal union index for 'F330': "+ unionIndex330)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex331 = (decoder.readIndex()); + if (unionIndex331 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(331, null); + } else { + if (unionIndex331 == 1) { + Utf8 charSequence331; + Object oldString331 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(331); + if (oldString331 instanceof Utf8) { + charSequence331 = (decoder).readString(((Utf8) oldString331)); + } else { + charSequence331 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(331, charSequence331); + } else { + throw new RuntimeException(("Illegal union index for 'F331': "+ unionIndex331)); + } + } + int unionIndex332 = (decoder.readIndex()); + if (unionIndex332 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(332, null); + } else { + if (unionIndex332 == 1) { + Utf8 charSequence332; + Object oldString332 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(332); + if (oldString332 instanceof Utf8) { + charSequence332 = (decoder).readString(((Utf8) oldString332)); + } else { + charSequence332 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(332, charSequence332); + } else { + throw new RuntimeException(("Illegal union index for 'F332': "+ unionIndex332)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex333 = (decoder.readIndex()); + if (unionIndex333 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(333, null); + } else { + if (unionIndex333 == 1) { + Utf8 charSequence333; + Object oldString333 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(333); + if (oldString333 instanceof Utf8) { + charSequence333 = (decoder).readString(((Utf8) oldString333)); + } else { + charSequence333 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(333, charSequence333); + } else { + throw new RuntimeException(("Illegal union index for 'F333': "+ unionIndex333)); + } + } + int unionIndex334 = (decoder.readIndex()); + if (unionIndex334 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(334, null); + } else { + if (unionIndex334 == 1) { + Utf8 charSequence334; + Object oldString334 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(334); + if (oldString334 instanceof Utf8) { + charSequence334 = (decoder).readString(((Utf8) oldString334)); + } else { + charSequence334 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(334, charSequence334); + } else { + throw new RuntimeException(("Illegal union index for 'F334': "+ unionIndex334)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex335 = (decoder.readIndex()); + if (unionIndex335 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(335, null); + } else { + if (unionIndex335 == 1) { + Utf8 charSequence335; + Object oldString335 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(335); + if (oldString335 instanceof Utf8) { + charSequence335 = (decoder).readString(((Utf8) oldString335)); + } else { + charSequence335 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(335, charSequence335); + } else { + throw new RuntimeException(("Illegal union index for 'F335': "+ unionIndex335)); + } + } + int unionIndex336 = (decoder.readIndex()); + if (unionIndex336 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(336, null); + } else { + if (unionIndex336 == 1) { + Utf8 charSequence336; + Object oldString336 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(336); + if (oldString336 instanceof Utf8) { + charSequence336 = (decoder).readString(((Utf8) oldString336)); + } else { + charSequence336 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(336, charSequence336); + } else { + throw new RuntimeException(("Illegal union index for 'F336': "+ unionIndex336)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex337 = (decoder.readIndex()); + if (unionIndex337 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(337, null); + } else { + if (unionIndex337 == 1) { + Utf8 charSequence337; + Object oldString337 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(337); + if (oldString337 instanceof Utf8) { + charSequence337 = (decoder).readString(((Utf8) oldString337)); + } else { + charSequence337 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(337, charSequence337); + } else { + throw new RuntimeException(("Illegal union index for 'F337': "+ unionIndex337)); + } + } + int unionIndex338 = (decoder.readIndex()); + if (unionIndex338 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(338, null); + } else { + if (unionIndex338 == 1) { + Utf8 charSequence338; + Object oldString338 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(338); + if (oldString338 instanceof Utf8) { + charSequence338 = (decoder).readString(((Utf8) oldString338)); + } else { + charSequence338 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(338, charSequence338); + } else { + throw new RuntimeException(("Illegal union index for 'F338': "+ unionIndex338)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex339 = (decoder.readIndex()); + if (unionIndex339 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(339, null); + } else { + if (unionIndex339 == 1) { + Utf8 charSequence339; + Object oldString339 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(339); + if (oldString339 instanceof Utf8) { + charSequence339 = (decoder).readString(((Utf8) oldString339)); + } else { + charSequence339 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(339, charSequence339); + } else { + throw new RuntimeException(("Illegal union index for 'F339': "+ unionIndex339)); + } + } + int unionIndex340 = (decoder.readIndex()); + if (unionIndex340 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(340, null); + } else { + if (unionIndex340 == 1) { + Utf8 charSequence340; + Object oldString340 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(340); + if (oldString340 instanceof Utf8) { + charSequence340 = (decoder).readString(((Utf8) oldString340)); + } else { + charSequence340 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(340, charSequence340); + } else { + throw new RuntimeException(("Illegal union index for 'F340': "+ unionIndex340)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex341 = (decoder.readIndex()); + if (unionIndex341 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(341, null); + } else { + if (unionIndex341 == 1) { + Utf8 charSequence341; + Object oldString341 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(341); + if (oldString341 instanceof Utf8) { + charSequence341 = (decoder).readString(((Utf8) oldString341)); + } else { + charSequence341 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(341, charSequence341); + } else { + throw new RuntimeException(("Illegal union index for 'F341': "+ unionIndex341)); + } + } + int unionIndex342 = (decoder.readIndex()); + if (unionIndex342 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(342, null); + } else { + if (unionIndex342 == 1) { + Utf8 charSequence342; + Object oldString342 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(342); + if (oldString342 instanceof Utf8) { + charSequence342 = (decoder).readString(((Utf8) oldString342)); + } else { + charSequence342 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(342, charSequence342); + } else { + throw new RuntimeException(("Illegal union index for 'F342': "+ unionIndex342)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex343 = (decoder.readIndex()); + if (unionIndex343 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(343, null); + } else { + if (unionIndex343 == 1) { + Utf8 charSequence343; + Object oldString343 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(343); + if (oldString343 instanceof Utf8) { + charSequence343 = (decoder).readString(((Utf8) oldString343)); + } else { + charSequence343 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(343, charSequence343); + } else { + throw new RuntimeException(("Illegal union index for 'F343': "+ unionIndex343)); + } + } + int unionIndex344 = (decoder.readIndex()); + if (unionIndex344 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(344, null); + } else { + if (unionIndex344 == 1) { + Utf8 charSequence344; + Object oldString344 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(344); + if (oldString344 instanceof Utf8) { + charSequence344 = (decoder).readString(((Utf8) oldString344)); + } else { + charSequence344 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(344, charSequence344); + } else { + throw new RuntimeException(("Illegal union index for 'F344': "+ unionIndex344)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex345 = (decoder.readIndex()); + if (unionIndex345 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(345, null); + } else { + if (unionIndex345 == 1) { + Utf8 charSequence345; + Object oldString345 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(345); + if (oldString345 instanceof Utf8) { + charSequence345 = (decoder).readString(((Utf8) oldString345)); + } else { + charSequence345 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(345, charSequence345); + } else { + throw new RuntimeException(("Illegal union index for 'F345': "+ unionIndex345)); + } + } + int unionIndex346 = (decoder.readIndex()); + if (unionIndex346 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(346, null); + } else { + if (unionIndex346 == 1) { + Utf8 charSequence346; + Object oldString346 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(346); + if (oldString346 instanceof Utf8) { + charSequence346 = (decoder).readString(((Utf8) oldString346)); + } else { + charSequence346 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(346, charSequence346); + } else { + throw new RuntimeException(("Illegal union index for 'F346': "+ unionIndex346)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex347 = (decoder.readIndex()); + if (unionIndex347 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(347, null); + } else { + if (unionIndex347 == 1) { + Utf8 charSequence347; + Object oldString347 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(347); + if (oldString347 instanceof Utf8) { + charSequence347 = (decoder).readString(((Utf8) oldString347)); + } else { + charSequence347 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(347, charSequence347); + } else { + throw new RuntimeException(("Illegal union index for 'F347': "+ unionIndex347)); + } + } + int unionIndex348 = (decoder.readIndex()); + if (unionIndex348 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(348, null); + } else { + if (unionIndex348 == 1) { + Utf8 charSequence348; + Object oldString348 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(348); + if (oldString348 instanceof Utf8) { + charSequence348 = (decoder).readString(((Utf8) oldString348)); + } else { + charSequence348 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(348, charSequence348); + } else { + throw new RuntimeException(("Illegal union index for 'F348': "+ unionIndex348)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex349 = (decoder.readIndex()); + if (unionIndex349 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(349, null); + } else { + if (unionIndex349 == 1) { + Utf8 charSequence349; + Object oldString349 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(349); + if (oldString349 instanceof Utf8) { + charSequence349 = (decoder).readString(((Utf8) oldString349)); + } else { + charSequence349 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(349, charSequence349); + } else { + throw new RuntimeException(("Illegal union index for 'F349': "+ unionIndex349)); + } + } + int unionIndex350 = (decoder.readIndex()); + if (unionIndex350 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(350, null); + } else { + if (unionIndex350 == 1) { + Utf8 charSequence350; + Object oldString350 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(350); + if (oldString350 instanceof Utf8) { + charSequence350 = (decoder).readString(((Utf8) oldString350)); + } else { + charSequence350 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(350, charSequence350); + } else { + throw new RuntimeException(("Illegal union index for 'F350': "+ unionIndex350)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex351 = (decoder.readIndex()); + if (unionIndex351 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(351, null); + } else { + if (unionIndex351 == 1) { + Utf8 charSequence351; + Object oldString351 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(351); + if (oldString351 instanceof Utf8) { + charSequence351 = (decoder).readString(((Utf8) oldString351)); + } else { + charSequence351 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(351, charSequence351); + } else { + throw new RuntimeException(("Illegal union index for 'F351': "+ unionIndex351)); + } + } + int unionIndex352 = (decoder.readIndex()); + if (unionIndex352 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(352, null); + } else { + if (unionIndex352 == 1) { + Utf8 charSequence352; + Object oldString352 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(352); + if (oldString352 instanceof Utf8) { + charSequence352 = (decoder).readString(((Utf8) oldString352)); + } else { + charSequence352 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(352, charSequence352); + } else { + throw new RuntimeException(("Illegal union index for 'F352': "+ unionIndex352)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex353 = (decoder.readIndex()); + if (unionIndex353 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(353, null); + } else { + if (unionIndex353 == 1) { + Utf8 charSequence353; + Object oldString353 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(353); + if (oldString353 instanceof Utf8) { + charSequence353 = (decoder).readString(((Utf8) oldString353)); + } else { + charSequence353 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(353, charSequence353); + } else { + throw new RuntimeException(("Illegal union index for 'F353': "+ unionIndex353)); + } + } + int unionIndex354 = (decoder.readIndex()); + if (unionIndex354 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(354, null); + } else { + if (unionIndex354 == 1) { + Utf8 charSequence354; + Object oldString354 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(354); + if (oldString354 instanceof Utf8) { + charSequence354 = (decoder).readString(((Utf8) oldString354)); + } else { + charSequence354 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(354, charSequence354); + } else { + throw new RuntimeException(("Illegal union index for 'F354': "+ unionIndex354)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex355 = (decoder.readIndex()); + if (unionIndex355 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(355, null); + } else { + if (unionIndex355 == 1) { + Utf8 charSequence355; + Object oldString355 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(355); + if (oldString355 instanceof Utf8) { + charSequence355 = (decoder).readString(((Utf8) oldString355)); + } else { + charSequence355 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(355, charSequence355); + } else { + throw new RuntimeException(("Illegal union index for 'F355': "+ unionIndex355)); + } + } + int unionIndex356 = (decoder.readIndex()); + if (unionIndex356 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(356, null); + } else { + if (unionIndex356 == 1) { + Utf8 charSequence356; + Object oldString356 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(356); + if (oldString356 instanceof Utf8) { + charSequence356 = (decoder).readString(((Utf8) oldString356)); + } else { + charSequence356 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(356, charSequence356); + } else { + throw new RuntimeException(("Illegal union index for 'F356': "+ unionIndex356)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex357 = (decoder.readIndex()); + if (unionIndex357 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(357, null); + } else { + if (unionIndex357 == 1) { + Utf8 charSequence357; + Object oldString357 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(357); + if (oldString357 instanceof Utf8) { + charSequence357 = (decoder).readString(((Utf8) oldString357)); + } else { + charSequence357 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(357, charSequence357); + } else { + throw new RuntimeException(("Illegal union index for 'F357': "+ unionIndex357)); + } + } + int unionIndex358 = (decoder.readIndex()); + if (unionIndex358 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(358, null); + } else { + if (unionIndex358 == 1) { + Utf8 charSequence358; + Object oldString358 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(358); + if (oldString358 instanceof Utf8) { + charSequence358 = (decoder).readString(((Utf8) oldString358)); + } else { + charSequence358 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(358, charSequence358); + } else { + throw new RuntimeException(("Illegal union index for 'F358': "+ unionIndex358)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex359 = (decoder.readIndex()); + if (unionIndex359 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(359, null); + } else { + if (unionIndex359 == 1) { + Utf8 charSequence359; + Object oldString359 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(359); + if (oldString359 instanceof Utf8) { + charSequence359 = (decoder).readString(((Utf8) oldString359)); + } else { + charSequence359 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(359, charSequence359); + } else { + throw new RuntimeException(("Illegal union index for 'F359': "+ unionIndex359)); + } + } + int unionIndex360 = (decoder.readIndex()); + if (unionIndex360 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(360, null); + } else { + if (unionIndex360 == 1) { + Utf8 charSequence360; + Object oldString360 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(360); + if (oldString360 instanceof Utf8) { + charSequence360 = (decoder).readString(((Utf8) oldString360)); + } else { + charSequence360 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(360, charSequence360); + } else { + throw new RuntimeException(("Illegal union index for 'F360': "+ unionIndex360)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex361 = (decoder.readIndex()); + if (unionIndex361 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(361, null); + } else { + if (unionIndex361 == 1) { + Utf8 charSequence361; + Object oldString361 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(361); + if (oldString361 instanceof Utf8) { + charSequence361 = (decoder).readString(((Utf8) oldString361)); + } else { + charSequence361 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(361, charSequence361); + } else { + throw new RuntimeException(("Illegal union index for 'F361': "+ unionIndex361)); + } + } + int unionIndex362 = (decoder.readIndex()); + if (unionIndex362 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(362, null); + } else { + if (unionIndex362 == 1) { + Utf8 charSequence362; + Object oldString362 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(362); + if (oldString362 instanceof Utf8) { + charSequence362 = (decoder).readString(((Utf8) oldString362)); + } else { + charSequence362 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(362, charSequence362); + } else { + throw new RuntimeException(("Illegal union index for 'F362': "+ unionIndex362)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex363 = (decoder.readIndex()); + if (unionIndex363 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(363, null); + } else { + if (unionIndex363 == 1) { + Utf8 charSequence363; + Object oldString363 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(363); + if (oldString363 instanceof Utf8) { + charSequence363 = (decoder).readString(((Utf8) oldString363)); + } else { + charSequence363 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(363, charSequence363); + } else { + throw new RuntimeException(("Illegal union index for 'F363': "+ unionIndex363)); + } + } + int unionIndex364 = (decoder.readIndex()); + if (unionIndex364 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(364, null); + } else { + if (unionIndex364 == 1) { + Utf8 charSequence364; + Object oldString364 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(364); + if (oldString364 instanceof Utf8) { + charSequence364 = (decoder).readString(((Utf8) oldString364)); + } else { + charSequence364 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(364, charSequence364); + } else { + throw new RuntimeException(("Illegal union index for 'F364': "+ unionIndex364)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex365 = (decoder.readIndex()); + if (unionIndex365 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(365, null); + } else { + if (unionIndex365 == 1) { + Utf8 charSequence365; + Object oldString365 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(365); + if (oldString365 instanceof Utf8) { + charSequence365 = (decoder).readString(((Utf8) oldString365)); + } else { + charSequence365 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(365, charSequence365); + } else { + throw new RuntimeException(("Illegal union index for 'F365': "+ unionIndex365)); + } + } + int unionIndex366 = (decoder.readIndex()); + if (unionIndex366 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(366, null); + } else { + if (unionIndex366 == 1) { + Utf8 charSequence366; + Object oldString366 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(366); + if (oldString366 instanceof Utf8) { + charSequence366 = (decoder).readString(((Utf8) oldString366)); + } else { + charSequence366 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(366, charSequence366); + } else { + throw new RuntimeException(("Illegal union index for 'F366': "+ unionIndex366)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex367 = (decoder.readIndex()); + if (unionIndex367 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(367, null); + } else { + if (unionIndex367 == 1) { + Utf8 charSequence367; + Object oldString367 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(367); + if (oldString367 instanceof Utf8) { + charSequence367 = (decoder).readString(((Utf8) oldString367)); + } else { + charSequence367 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(367, charSequence367); + } else { + throw new RuntimeException(("Illegal union index for 'F367': "+ unionIndex367)); + } + } + int unionIndex368 = (decoder.readIndex()); + if (unionIndex368 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(368, null); + } else { + if (unionIndex368 == 1) { + Utf8 charSequence368; + Object oldString368 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(368); + if (oldString368 instanceof Utf8) { + charSequence368 = (decoder).readString(((Utf8) oldString368)); + } else { + charSequence368 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(368, charSequence368); + } else { + throw new RuntimeException(("Illegal union index for 'F368': "+ unionIndex368)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex369 = (decoder.readIndex()); + if (unionIndex369 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(369, null); + } else { + if (unionIndex369 == 1) { + Utf8 charSequence369; + Object oldString369 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(369); + if (oldString369 instanceof Utf8) { + charSequence369 = (decoder).readString(((Utf8) oldString369)); + } else { + charSequence369 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(369, charSequence369); + } else { + throw new RuntimeException(("Illegal union index for 'F369': "+ unionIndex369)); + } + } + int unionIndex370 = (decoder.readIndex()); + if (unionIndex370 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(370, null); + } else { + if (unionIndex370 == 1) { + Utf8 charSequence370; + Object oldString370 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(370); + if (oldString370 instanceof Utf8) { + charSequence370 = (decoder).readString(((Utf8) oldString370)); + } else { + charSequence370 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(370, charSequence370); + } else { + throw new RuntimeException(("Illegal union index for 'F370': "+ unionIndex370)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex371 = (decoder.readIndex()); + if (unionIndex371 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(371, null); + } else { + if (unionIndex371 == 1) { + Utf8 charSequence371; + Object oldString371 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(371); + if (oldString371 instanceof Utf8) { + charSequence371 = (decoder).readString(((Utf8) oldString371)); + } else { + charSequence371 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(371, charSequence371); + } else { + throw new RuntimeException(("Illegal union index for 'F371': "+ unionIndex371)); + } + } + int unionIndex372 = (decoder.readIndex()); + if (unionIndex372 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(372, null); + } else { + if (unionIndex372 == 1) { + Utf8 charSequence372; + Object oldString372 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(372); + if (oldString372 instanceof Utf8) { + charSequence372 = (decoder).readString(((Utf8) oldString372)); + } else { + charSequence372 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(372, charSequence372); + } else { + throw new RuntimeException(("Illegal union index for 'F372': "+ unionIndex372)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex373 = (decoder.readIndex()); + if (unionIndex373 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(373, null); + } else { + if (unionIndex373 == 1) { + Utf8 charSequence373; + Object oldString373 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(373); + if (oldString373 instanceof Utf8) { + charSequence373 = (decoder).readString(((Utf8) oldString373)); + } else { + charSequence373 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(373, charSequence373); + } else { + throw new RuntimeException(("Illegal union index for 'F373': "+ unionIndex373)); + } + } + int unionIndex374 = (decoder.readIndex()); + if (unionIndex374 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(374, null); + } else { + if (unionIndex374 == 1) { + Utf8 charSequence374; + Object oldString374 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(374); + if (oldString374 instanceof Utf8) { + charSequence374 = (decoder).readString(((Utf8) oldString374)); + } else { + charSequence374 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(374, charSequence374); + } else { + throw new RuntimeException(("Illegal union index for 'F374': "+ unionIndex374)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex375 = (decoder.readIndex()); + if (unionIndex375 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(375, null); + } else { + if (unionIndex375 == 1) { + Utf8 charSequence375; + Object oldString375 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(375); + if (oldString375 instanceof Utf8) { + charSequence375 = (decoder).readString(((Utf8) oldString375)); + } else { + charSequence375 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(375, charSequence375); + } else { + throw new RuntimeException(("Illegal union index for 'F375': "+ unionIndex375)); + } + } + int unionIndex376 = (decoder.readIndex()); + if (unionIndex376 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(376, null); + } else { + if (unionIndex376 == 1) { + Utf8 charSequence376; + Object oldString376 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(376); + if (oldString376 instanceof Utf8) { + charSequence376 = (decoder).readString(((Utf8) oldString376)); + } else { + charSequence376 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(376, charSequence376); + } else { + throw new RuntimeException(("Illegal union index for 'F376': "+ unionIndex376)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex377 = (decoder.readIndex()); + if (unionIndex377 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(377, null); + } else { + if (unionIndex377 == 1) { + Utf8 charSequence377; + Object oldString377 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(377); + if (oldString377 instanceof Utf8) { + charSequence377 = (decoder).readString(((Utf8) oldString377)); + } else { + charSequence377 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(377, charSequence377); + } else { + throw new RuntimeException(("Illegal union index for 'F377': "+ unionIndex377)); + } + } + int unionIndex378 = (decoder.readIndex()); + if (unionIndex378 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(378, null); + } else { + if (unionIndex378 == 1) { + Utf8 charSequence378; + Object oldString378 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(378); + if (oldString378 instanceof Utf8) { + charSequence378 = (decoder).readString(((Utf8) oldString378)); + } else { + charSequence378 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(378, charSequence378); + } else { + throw new RuntimeException(("Illegal union index for 'F378': "+ unionIndex378)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex379 = (decoder.readIndex()); + if (unionIndex379 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(379, null); + } else { + if (unionIndex379 == 1) { + Utf8 charSequence379; + Object oldString379 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(379); + if (oldString379 instanceof Utf8) { + charSequence379 = (decoder).readString(((Utf8) oldString379)); + } else { + charSequence379 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(379, charSequence379); + } else { + throw new RuntimeException(("Illegal union index for 'F379': "+ unionIndex379)); + } + } + int unionIndex380 = (decoder.readIndex()); + if (unionIndex380 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(380, null); + } else { + if (unionIndex380 == 1) { + Utf8 charSequence380; + Object oldString380 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(380); + if (oldString380 instanceof Utf8) { + charSequence380 = (decoder).readString(((Utf8) oldString380)); + } else { + charSequence380 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(380, charSequence380); + } else { + throw new RuntimeException(("Illegal union index for 'F380': "+ unionIndex380)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex381 = (decoder.readIndex()); + if (unionIndex381 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(381, null); + } else { + if (unionIndex381 == 1) { + Utf8 charSequence381; + Object oldString381 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(381); + if (oldString381 instanceof Utf8) { + charSequence381 = (decoder).readString(((Utf8) oldString381)); + } else { + charSequence381 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(381, charSequence381); + } else { + throw new RuntimeException(("Illegal union index for 'F381': "+ unionIndex381)); + } + } + int unionIndex382 = (decoder.readIndex()); + if (unionIndex382 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(382, null); + } else { + if (unionIndex382 == 1) { + Utf8 charSequence382; + Object oldString382 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(382); + if (oldString382 instanceof Utf8) { + charSequence382 = (decoder).readString(((Utf8) oldString382)); + } else { + charSequence382 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(382, charSequence382); + } else { + throw new RuntimeException(("Illegal union index for 'F382': "+ unionIndex382)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex383 = (decoder.readIndex()); + if (unionIndex383 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(383, null); + } else { + if (unionIndex383 == 1) { + Utf8 charSequence383; + Object oldString383 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(383); + if (oldString383 instanceof Utf8) { + charSequence383 = (decoder).readString(((Utf8) oldString383)); + } else { + charSequence383 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(383, charSequence383); + } else { + throw new RuntimeException(("Illegal union index for 'F383': "+ unionIndex383)); + } + } + int unionIndex384 = (decoder.readIndex()); + if (unionIndex384 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(384, null); + } else { + if (unionIndex384 == 1) { + Utf8 charSequence384; + Object oldString384 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(384); + if (oldString384 instanceof Utf8) { + charSequence384 = (decoder).readString(((Utf8) oldString384)); + } else { + charSequence384 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(384, charSequence384); + } else { + throw new RuntimeException(("Illegal union index for 'F384': "+ unionIndex384)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex385 = (decoder.readIndex()); + if (unionIndex385 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(385, null); + } else { + if (unionIndex385 == 1) { + Utf8 charSequence385; + Object oldString385 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(385); + if (oldString385 instanceof Utf8) { + charSequence385 = (decoder).readString(((Utf8) oldString385)); + } else { + charSequence385 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(385, charSequence385); + } else { + throw new RuntimeException(("Illegal union index for 'F385': "+ unionIndex385)); + } + } + int unionIndex386 = (decoder.readIndex()); + if (unionIndex386 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(386, null); + } else { + if (unionIndex386 == 1) { + Utf8 charSequence386; + Object oldString386 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(386); + if (oldString386 instanceof Utf8) { + charSequence386 = (decoder).readString(((Utf8) oldString386)); + } else { + charSequence386 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(386, charSequence386); + } else { + throw new RuntimeException(("Illegal union index for 'F386': "+ unionIndex386)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex387 = (decoder.readIndex()); + if (unionIndex387 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(387, null); + } else { + if (unionIndex387 == 1) { + Utf8 charSequence387; + Object oldString387 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(387); + if (oldString387 instanceof Utf8) { + charSequence387 = (decoder).readString(((Utf8) oldString387)); + } else { + charSequence387 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(387, charSequence387); + } else { + throw new RuntimeException(("Illegal union index for 'F387': "+ unionIndex387)); + } + } + int unionIndex388 = (decoder.readIndex()); + if (unionIndex388 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(388, null); + } else { + if (unionIndex388 == 1) { + Utf8 charSequence388; + Object oldString388 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(388); + if (oldString388 instanceof Utf8) { + charSequence388 = (decoder).readString(((Utf8) oldString388)); + } else { + charSequence388 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(388, charSequence388); + } else { + throw new RuntimeException(("Illegal union index for 'F388': "+ unionIndex388)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex389 = (decoder.readIndex()); + if (unionIndex389 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(389, null); + } else { + if (unionIndex389 == 1) { + Utf8 charSequence389; + Object oldString389 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(389); + if (oldString389 instanceof Utf8) { + charSequence389 = (decoder).readString(((Utf8) oldString389)); + } else { + charSequence389 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(389, charSequence389); + } else { + throw new RuntimeException(("Illegal union index for 'F389': "+ unionIndex389)); + } + } + int unionIndex390 = (decoder.readIndex()); + if (unionIndex390 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(390, null); + } else { + if (unionIndex390 == 1) { + Utf8 charSequence390; + Object oldString390 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(390); + if (oldString390 instanceof Utf8) { + charSequence390 = (decoder).readString(((Utf8) oldString390)); + } else { + charSequence390 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(390, charSequence390); + } else { + throw new RuntimeException(("Illegal union index for 'F390': "+ unionIndex390)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex391 = (decoder.readIndex()); + if (unionIndex391 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(391, null); + } else { + if (unionIndex391 == 1) { + Utf8 charSequence391; + Object oldString391 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(391); + if (oldString391 instanceof Utf8) { + charSequence391 = (decoder).readString(((Utf8) oldString391)); + } else { + charSequence391 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(391, charSequence391); + } else { + throw new RuntimeException(("Illegal union index for 'F391': "+ unionIndex391)); + } + } + int unionIndex392 = (decoder.readIndex()); + if (unionIndex392 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(392, null); + } else { + if (unionIndex392 == 1) { + Utf8 charSequence392; + Object oldString392 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(392); + if (oldString392 instanceof Utf8) { + charSequence392 = (decoder).readString(((Utf8) oldString392)); + } else { + charSequence392 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(392, charSequence392); + } else { + throw new RuntimeException(("Illegal union index for 'F392': "+ unionIndex392)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex393 = (decoder.readIndex()); + if (unionIndex393 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(393, null); + } else { + if (unionIndex393 == 1) { + Utf8 charSequence393; + Object oldString393 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(393); + if (oldString393 instanceof Utf8) { + charSequence393 = (decoder).readString(((Utf8) oldString393)); + } else { + charSequence393 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(393, charSequence393); + } else { + throw new RuntimeException(("Illegal union index for 'F393': "+ unionIndex393)); + } + } + int unionIndex394 = (decoder.readIndex()); + if (unionIndex394 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(394, null); + } else { + if (unionIndex394 == 1) { + Utf8 charSequence394; + Object oldString394 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(394); + if (oldString394 instanceof Utf8) { + charSequence394 = (decoder).readString(((Utf8) oldString394)); + } else { + charSequence394 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(394, charSequence394); + } else { + throw new RuntimeException(("Illegal union index for 'F394': "+ unionIndex394)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex395 = (decoder.readIndex()); + if (unionIndex395 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(395, null); + } else { + if (unionIndex395 == 1) { + Utf8 charSequence395; + Object oldString395 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(395); + if (oldString395 instanceof Utf8) { + charSequence395 = (decoder).readString(((Utf8) oldString395)); + } else { + charSequence395 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(395, charSequence395); + } else { + throw new RuntimeException(("Illegal union index for 'F395': "+ unionIndex395)); + } + } + int unionIndex396 = (decoder.readIndex()); + if (unionIndex396 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(396, null); + } else { + if (unionIndex396 == 1) { + Utf8 charSequence396; + Object oldString396 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(396); + if (oldString396 instanceof Utf8) { + charSequence396 = (decoder).readString(((Utf8) oldString396)); + } else { + charSequence396 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(396, charSequence396); + } else { + throw new RuntimeException(("Illegal union index for 'F396': "+ unionIndex396)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex397 = (decoder.readIndex()); + if (unionIndex397 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(397, null); + } else { + if (unionIndex397 == 1) { + Utf8 charSequence397; + Object oldString397 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(397); + if (oldString397 instanceof Utf8) { + charSequence397 = (decoder).readString(((Utf8) oldString397)); + } else { + charSequence397 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(397, charSequence397); + } else { + throw new RuntimeException(("Illegal union index for 'F397': "+ unionIndex397)); + } + } + int unionIndex398 = (decoder.readIndex()); + if (unionIndex398 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(398, null); + } else { + if (unionIndex398 == 1) { + Utf8 charSequence398; + Object oldString398 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(398); + if (oldString398 instanceof Utf8) { + charSequence398 = (decoder).readString(((Utf8) oldString398)); + } else { + charSequence398 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(398, charSequence398); + } else { + throw new RuntimeException(("Illegal union index for 'F398': "+ unionIndex398)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex399 = (decoder.readIndex()); + if (unionIndex399 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(399, null); + } else { + if (unionIndex399 == 1) { + Utf8 charSequence399; + Object oldString399 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(399); + if (oldString399 instanceof Utf8) { + charSequence399 = (decoder).readString(((Utf8) oldString399)); + } else { + charSequence399 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(399, charSequence399); + } else { + throw new RuntimeException(("Illegal union index for 'F399': "+ unionIndex399)); + } + } + int unionIndex400 = (decoder.readIndex()); + if (unionIndex400 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(400, null); + } else { + if (unionIndex400 == 1) { + Utf8 charSequence400; + Object oldString400 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(400); + if (oldString400 instanceof Utf8) { + charSequence400 = (decoder).readString(((Utf8) oldString400)); + } else { + charSequence400 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(400, charSequence400); + } else { + throw new RuntimeException(("Illegal union index for 'F400': "+ unionIndex400)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex401 = (decoder.readIndex()); + if (unionIndex401 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(401, null); + } else { + if (unionIndex401 == 1) { + Utf8 charSequence401; + Object oldString401 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(401); + if (oldString401 instanceof Utf8) { + charSequence401 = (decoder).readString(((Utf8) oldString401)); + } else { + charSequence401 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(401, charSequence401); + } else { + throw new RuntimeException(("Illegal union index for 'F401': "+ unionIndex401)); + } + } + int unionIndex402 = (decoder.readIndex()); + if (unionIndex402 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(402, null); + } else { + if (unionIndex402 == 1) { + Utf8 charSequence402; + Object oldString402 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(402); + if (oldString402 instanceof Utf8) { + charSequence402 = (decoder).readString(((Utf8) oldString402)); + } else { + charSequence402 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(402, charSequence402); + } else { + throw new RuntimeException(("Illegal union index for 'F402': "+ unionIndex402)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex403 = (decoder.readIndex()); + if (unionIndex403 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(403, null); + } else { + if (unionIndex403 == 1) { + Utf8 charSequence403; + Object oldString403 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(403); + if (oldString403 instanceof Utf8) { + charSequence403 = (decoder).readString(((Utf8) oldString403)); + } else { + charSequence403 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(403, charSequence403); + } else { + throw new RuntimeException(("Illegal union index for 'F403': "+ unionIndex403)); + } + } + int unionIndex404 = (decoder.readIndex()); + if (unionIndex404 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(404, null); + } else { + if (unionIndex404 == 1) { + Utf8 charSequence404; + Object oldString404 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(404); + if (oldString404 instanceof Utf8) { + charSequence404 = (decoder).readString(((Utf8) oldString404)); + } else { + charSequence404 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(404, charSequence404); + } else { + throw new RuntimeException(("Illegal union index for 'F404': "+ unionIndex404)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex405 = (decoder.readIndex()); + if (unionIndex405 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(405, null); + } else { + if (unionIndex405 == 1) { + Utf8 charSequence405; + Object oldString405 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(405); + if (oldString405 instanceof Utf8) { + charSequence405 = (decoder).readString(((Utf8) oldString405)); + } else { + charSequence405 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(405, charSequence405); + } else { + throw new RuntimeException(("Illegal union index for 'F405': "+ unionIndex405)); + } + } + int unionIndex406 = (decoder.readIndex()); + if (unionIndex406 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(406, null); + } else { + if (unionIndex406 == 1) { + Utf8 charSequence406; + Object oldString406 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(406); + if (oldString406 instanceof Utf8) { + charSequence406 = (decoder).readString(((Utf8) oldString406)); + } else { + charSequence406 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(406, charSequence406); + } else { + throw new RuntimeException(("Illegal union index for 'F406': "+ unionIndex406)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex407 = (decoder.readIndex()); + if (unionIndex407 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(407, null); + } else { + if (unionIndex407 == 1) { + Utf8 charSequence407; + Object oldString407 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(407); + if (oldString407 instanceof Utf8) { + charSequence407 = (decoder).readString(((Utf8) oldString407)); + } else { + charSequence407 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(407, charSequence407); + } else { + throw new RuntimeException(("Illegal union index for 'F407': "+ unionIndex407)); + } + } + int unionIndex408 = (decoder.readIndex()); + if (unionIndex408 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(408, null); + } else { + if (unionIndex408 == 1) { + Utf8 charSequence408; + Object oldString408 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(408); + if (oldString408 instanceof Utf8) { + charSequence408 = (decoder).readString(((Utf8) oldString408)); + } else { + charSequence408 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(408, charSequence408); + } else { + throw new RuntimeException(("Illegal union index for 'F408': "+ unionIndex408)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex409 = (decoder.readIndex()); + if (unionIndex409 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(409, null); + } else { + if (unionIndex409 == 1) { + Utf8 charSequence409; + Object oldString409 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(409); + if (oldString409 instanceof Utf8) { + charSequence409 = (decoder).readString(((Utf8) oldString409)); + } else { + charSequence409 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(409, charSequence409); + } else { + throw new RuntimeException(("Illegal union index for 'F409': "+ unionIndex409)); + } + } + int unionIndex410 = (decoder.readIndex()); + if (unionIndex410 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(410, null); + } else { + if (unionIndex410 == 1) { + Utf8 charSequence410; + Object oldString410 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(410); + if (oldString410 instanceof Utf8) { + charSequence410 = (decoder).readString(((Utf8) oldString410)); + } else { + charSequence410 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(410, charSequence410); + } else { + throw new RuntimeException(("Illegal union index for 'F410': "+ unionIndex410)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex411 = (decoder.readIndex()); + if (unionIndex411 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(411, null); + } else { + if (unionIndex411 == 1) { + Utf8 charSequence411; + Object oldString411 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(411); + if (oldString411 instanceof Utf8) { + charSequence411 = (decoder).readString(((Utf8) oldString411)); + } else { + charSequence411 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(411, charSequence411); + } else { + throw new RuntimeException(("Illegal union index for 'F411': "+ unionIndex411)); + } + } + int unionIndex412 = (decoder.readIndex()); + if (unionIndex412 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(412, null); + } else { + if (unionIndex412 == 1) { + Utf8 charSequence412; + Object oldString412 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(412); + if (oldString412 instanceof Utf8) { + charSequence412 = (decoder).readString(((Utf8) oldString412)); + } else { + charSequence412 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(412, charSequence412); + } else { + throw new RuntimeException(("Illegal union index for 'F412': "+ unionIndex412)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex413 = (decoder.readIndex()); + if (unionIndex413 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(413, null); + } else { + if (unionIndex413 == 1) { + Utf8 charSequence413; + Object oldString413 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(413); + if (oldString413 instanceof Utf8) { + charSequence413 = (decoder).readString(((Utf8) oldString413)); + } else { + charSequence413 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(413, charSequence413); + } else { + throw new RuntimeException(("Illegal union index for 'F413': "+ unionIndex413)); + } + } + int unionIndex414 = (decoder.readIndex()); + if (unionIndex414 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(414, null); + } else { + if (unionIndex414 == 1) { + Utf8 charSequence414; + Object oldString414 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(414); + if (oldString414 instanceof Utf8) { + charSequence414 = (decoder).readString(((Utf8) oldString414)); + } else { + charSequence414 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(414, charSequence414); + } else { + throw new RuntimeException(("Illegal union index for 'F414': "+ unionIndex414)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex415 = (decoder.readIndex()); + if (unionIndex415 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(415, null); + } else { + if (unionIndex415 == 1) { + Utf8 charSequence415; + Object oldString415 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(415); + if (oldString415 instanceof Utf8) { + charSequence415 = (decoder).readString(((Utf8) oldString415)); + } else { + charSequence415 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(415, charSequence415); + } else { + throw new RuntimeException(("Illegal union index for 'F415': "+ unionIndex415)); + } + } + int unionIndex416 = (decoder.readIndex()); + if (unionIndex416 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(416, null); + } else { + if (unionIndex416 == 1) { + Utf8 charSequence416; + Object oldString416 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(416); + if (oldString416 instanceof Utf8) { + charSequence416 = (decoder).readString(((Utf8) oldString416)); + } else { + charSequence416 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(416, charSequence416); + } else { + throw new RuntimeException(("Illegal union index for 'F416': "+ unionIndex416)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex417 = (decoder.readIndex()); + if (unionIndex417 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(417, null); + } else { + if (unionIndex417 == 1) { + Utf8 charSequence417; + Object oldString417 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(417); + if (oldString417 instanceof Utf8) { + charSequence417 = (decoder).readString(((Utf8) oldString417)); + } else { + charSequence417 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(417, charSequence417); + } else { + throw new RuntimeException(("Illegal union index for 'F417': "+ unionIndex417)); + } + } + int unionIndex418 = (decoder.readIndex()); + if (unionIndex418 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(418, null); + } else { + if (unionIndex418 == 1) { + Utf8 charSequence418; + Object oldString418 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(418); + if (oldString418 instanceof Utf8) { + charSequence418 = (decoder).readString(((Utf8) oldString418)); + } else { + charSequence418 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(418, charSequence418); + } else { + throw new RuntimeException(("Illegal union index for 'F418': "+ unionIndex418)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex419 = (decoder.readIndex()); + if (unionIndex419 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(419, null); + } else { + if (unionIndex419 == 1) { + Utf8 charSequence419; + Object oldString419 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(419); + if (oldString419 instanceof Utf8) { + charSequence419 = (decoder).readString(((Utf8) oldString419)); + } else { + charSequence419 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(419, charSequence419); + } else { + throw new RuntimeException(("Illegal union index for 'F419': "+ unionIndex419)); + } + } + int unionIndex420 = (decoder.readIndex()); + if (unionIndex420 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(420, null); + } else { + if (unionIndex420 == 1) { + Utf8 charSequence420; + Object oldString420 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(420); + if (oldString420 instanceof Utf8) { + charSequence420 = (decoder).readString(((Utf8) oldString420)); + } else { + charSequence420 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(420, charSequence420); + } else { + throw new RuntimeException(("Illegal union index for 'F420': "+ unionIndex420)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex421 = (decoder.readIndex()); + if (unionIndex421 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(421, null); + } else { + if (unionIndex421 == 1) { + Utf8 charSequence421; + Object oldString421 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(421); + if (oldString421 instanceof Utf8) { + charSequence421 = (decoder).readString(((Utf8) oldString421)); + } else { + charSequence421 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(421, charSequence421); + } else { + throw new RuntimeException(("Illegal union index for 'F421': "+ unionIndex421)); + } + } + int unionIndex422 = (decoder.readIndex()); + if (unionIndex422 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(422, null); + } else { + if (unionIndex422 == 1) { + Utf8 charSequence422; + Object oldString422 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(422); + if (oldString422 instanceof Utf8) { + charSequence422 = (decoder).readString(((Utf8) oldString422)); + } else { + charSequence422 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(422, charSequence422); + } else { + throw new RuntimeException(("Illegal union index for 'F422': "+ unionIndex422)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex423 = (decoder.readIndex()); + if (unionIndex423 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(423, null); + } else { + if (unionIndex423 == 1) { + Utf8 charSequence423; + Object oldString423 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(423); + if (oldString423 instanceof Utf8) { + charSequence423 = (decoder).readString(((Utf8) oldString423)); + } else { + charSequence423 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(423, charSequence423); + } else { + throw new RuntimeException(("Illegal union index for 'F423': "+ unionIndex423)); + } + } + int unionIndex424 = (decoder.readIndex()); + if (unionIndex424 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(424, null); + } else { + if (unionIndex424 == 1) { + Utf8 charSequence424; + Object oldString424 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(424); + if (oldString424 instanceof Utf8) { + charSequence424 = (decoder).readString(((Utf8) oldString424)); + } else { + charSequence424 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(424, charSequence424); + } else { + throw new RuntimeException(("Illegal union index for 'F424': "+ unionIndex424)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex425 = (decoder.readIndex()); + if (unionIndex425 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(425, null); + } else { + if (unionIndex425 == 1) { + Utf8 charSequence425; + Object oldString425 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(425); + if (oldString425 instanceof Utf8) { + charSequence425 = (decoder).readString(((Utf8) oldString425)); + } else { + charSequence425 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(425, charSequence425); + } else { + throw new RuntimeException(("Illegal union index for 'F425': "+ unionIndex425)); + } + } + int unionIndex426 = (decoder.readIndex()); + if (unionIndex426 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(426, null); + } else { + if (unionIndex426 == 1) { + Utf8 charSequence426; + Object oldString426 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(426); + if (oldString426 instanceof Utf8) { + charSequence426 = (decoder).readString(((Utf8) oldString426)); + } else { + charSequence426 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(426, charSequence426); + } else { + throw new RuntimeException(("Illegal union index for 'F426': "+ unionIndex426)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex427 = (decoder.readIndex()); + if (unionIndex427 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(427, null); + } else { + if (unionIndex427 == 1) { + Utf8 charSequence427; + Object oldString427 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(427); + if (oldString427 instanceof Utf8) { + charSequence427 = (decoder).readString(((Utf8) oldString427)); + } else { + charSequence427 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(427, charSequence427); + } else { + throw new RuntimeException(("Illegal union index for 'F427': "+ unionIndex427)); + } + } + int unionIndex428 = (decoder.readIndex()); + if (unionIndex428 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(428, null); + } else { + if (unionIndex428 == 1) { + Utf8 charSequence428; + Object oldString428 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(428); + if (oldString428 instanceof Utf8) { + charSequence428 = (decoder).readString(((Utf8) oldString428)); + } else { + charSequence428 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(428, charSequence428); + } else { + throw new RuntimeException(("Illegal union index for 'F428': "+ unionIndex428)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex429 = (decoder.readIndex()); + if (unionIndex429 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(429, null); + } else { + if (unionIndex429 == 1) { + Utf8 charSequence429; + Object oldString429 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(429); + if (oldString429 instanceof Utf8) { + charSequence429 = (decoder).readString(((Utf8) oldString429)); + } else { + charSequence429 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(429, charSequence429); + } else { + throw new RuntimeException(("Illegal union index for 'F429': "+ unionIndex429)); + } + } + int unionIndex430 = (decoder.readIndex()); + if (unionIndex430 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(430, null); + } else { + if (unionIndex430 == 1) { + Utf8 charSequence430; + Object oldString430 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(430); + if (oldString430 instanceof Utf8) { + charSequence430 = (decoder).readString(((Utf8) oldString430)); + } else { + charSequence430 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(430, charSequence430); + } else { + throw new RuntimeException(("Illegal union index for 'F430': "+ unionIndex430)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex431 = (decoder.readIndex()); + if (unionIndex431 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(431, null); + } else { + if (unionIndex431 == 1) { + Utf8 charSequence431; + Object oldString431 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(431); + if (oldString431 instanceof Utf8) { + charSequence431 = (decoder).readString(((Utf8) oldString431)); + } else { + charSequence431 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(431, charSequence431); + } else { + throw new RuntimeException(("Illegal union index for 'F431': "+ unionIndex431)); + } + } + int unionIndex432 = (decoder.readIndex()); + if (unionIndex432 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(432, null); + } else { + if (unionIndex432 == 1) { + Utf8 charSequence432; + Object oldString432 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(432); + if (oldString432 instanceof Utf8) { + charSequence432 = (decoder).readString(((Utf8) oldString432)); + } else { + charSequence432 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(432, charSequence432); + } else { + throw new RuntimeException(("Illegal union index for 'F432': "+ unionIndex432)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex433 = (decoder.readIndex()); + if (unionIndex433 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(433, null); + } else { + if (unionIndex433 == 1) { + Utf8 charSequence433; + Object oldString433 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(433); + if (oldString433 instanceof Utf8) { + charSequence433 = (decoder).readString(((Utf8) oldString433)); + } else { + charSequence433 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(433, charSequence433); + } else { + throw new RuntimeException(("Illegal union index for 'F433': "+ unionIndex433)); + } + } + int unionIndex434 = (decoder.readIndex()); + if (unionIndex434 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(434, null); + } else { + if (unionIndex434 == 1) { + Utf8 charSequence434; + Object oldString434 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(434); + if (oldString434 instanceof Utf8) { + charSequence434 = (decoder).readString(((Utf8) oldString434)); + } else { + charSequence434 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(434, charSequence434); + } else { + throw new RuntimeException(("Illegal union index for 'F434': "+ unionIndex434)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex435 = (decoder.readIndex()); + if (unionIndex435 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(435, null); + } else { + if (unionIndex435 == 1) { + Utf8 charSequence435; + Object oldString435 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(435); + if (oldString435 instanceof Utf8) { + charSequence435 = (decoder).readString(((Utf8) oldString435)); + } else { + charSequence435 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(435, charSequence435); + } else { + throw new RuntimeException(("Illegal union index for 'F435': "+ unionIndex435)); + } + } + int unionIndex436 = (decoder.readIndex()); + if (unionIndex436 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(436, null); + } else { + if (unionIndex436 == 1) { + Utf8 charSequence436; + Object oldString436 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(436); + if (oldString436 instanceof Utf8) { + charSequence436 = (decoder).readString(((Utf8) oldString436)); + } else { + charSequence436 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(436, charSequence436); + } else { + throw new RuntimeException(("Illegal union index for 'F436': "+ unionIndex436)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex437 = (decoder.readIndex()); + if (unionIndex437 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(437, null); + } else { + if (unionIndex437 == 1) { + Utf8 charSequence437; + Object oldString437 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(437); + if (oldString437 instanceof Utf8) { + charSequence437 = (decoder).readString(((Utf8) oldString437)); + } else { + charSequence437 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(437, charSequence437); + } else { + throw new RuntimeException(("Illegal union index for 'F437': "+ unionIndex437)); + } + } + int unionIndex438 = (decoder.readIndex()); + if (unionIndex438 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(438, null); + } else { + if (unionIndex438 == 1) { + Utf8 charSequence438; + Object oldString438 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(438); + if (oldString438 instanceof Utf8) { + charSequence438 = (decoder).readString(((Utf8) oldString438)); + } else { + charSequence438 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(438, charSequence438); + } else { + throw new RuntimeException(("Illegal union index for 'F438': "+ unionIndex438)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex439 = (decoder.readIndex()); + if (unionIndex439 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(439, null); + } else { + if (unionIndex439 == 1) { + Utf8 charSequence439; + Object oldString439 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(439); + if (oldString439 instanceof Utf8) { + charSequence439 = (decoder).readString(((Utf8) oldString439)); + } else { + charSequence439 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(439, charSequence439); + } else { + throw new RuntimeException(("Illegal union index for 'F439': "+ unionIndex439)); + } + } + int unionIndex440 = (decoder.readIndex()); + if (unionIndex440 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(440, null); + } else { + if (unionIndex440 == 1) { + Utf8 charSequence440; + Object oldString440 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(440); + if (oldString440 instanceof Utf8) { + charSequence440 = (decoder).readString(((Utf8) oldString440)); + } else { + charSequence440 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(440, charSequence440); + } else { + throw new RuntimeException(("Illegal union index for 'F440': "+ unionIndex440)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex441 = (decoder.readIndex()); + if (unionIndex441 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(441, null); + } else { + if (unionIndex441 == 1) { + Utf8 charSequence441; + Object oldString441 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(441); + if (oldString441 instanceof Utf8) { + charSequence441 = (decoder).readString(((Utf8) oldString441)); + } else { + charSequence441 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(441, charSequence441); + } else { + throw new RuntimeException(("Illegal union index for 'F441': "+ unionIndex441)); + } + } + int unionIndex442 = (decoder.readIndex()); + if (unionIndex442 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(442, null); + } else { + if (unionIndex442 == 1) { + Utf8 charSequence442; + Object oldString442 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(442); + if (oldString442 instanceof Utf8) { + charSequence442 = (decoder).readString(((Utf8) oldString442)); + } else { + charSequence442 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(442, charSequence442); + } else { + throw new RuntimeException(("Illegal union index for 'F442': "+ unionIndex442)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex443 = (decoder.readIndex()); + if (unionIndex443 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(443, null); + } else { + if (unionIndex443 == 1) { + Utf8 charSequence443; + Object oldString443 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(443); + if (oldString443 instanceof Utf8) { + charSequence443 = (decoder).readString(((Utf8) oldString443)); + } else { + charSequence443 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(443, charSequence443); + } else { + throw new RuntimeException(("Illegal union index for 'F443': "+ unionIndex443)); + } + } + int unionIndex444 = (decoder.readIndex()); + if (unionIndex444 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(444, null); + } else { + if (unionIndex444 == 1) { + Utf8 charSequence444; + Object oldString444 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(444); + if (oldString444 instanceof Utf8) { + charSequence444 = (decoder).readString(((Utf8) oldString444)); + } else { + charSequence444 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(444, charSequence444); + } else { + throw new RuntimeException(("Illegal union index for 'F444': "+ unionIndex444)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex445 = (decoder.readIndex()); + if (unionIndex445 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(445, null); + } else { + if (unionIndex445 == 1) { + Utf8 charSequence445; + Object oldString445 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(445); + if (oldString445 instanceof Utf8) { + charSequence445 = (decoder).readString(((Utf8) oldString445)); + } else { + charSequence445 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(445, charSequence445); + } else { + throw new RuntimeException(("Illegal union index for 'F445': "+ unionIndex445)); + } + } + int unionIndex446 = (decoder.readIndex()); + if (unionIndex446 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(446, null); + } else { + if (unionIndex446 == 1) { + Utf8 charSequence446; + Object oldString446 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(446); + if (oldString446 instanceof Utf8) { + charSequence446 = (decoder).readString(((Utf8) oldString446)); + } else { + charSequence446 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(446, charSequence446); + } else { + throw new RuntimeException(("Illegal union index for 'F446': "+ unionIndex446)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex447 = (decoder.readIndex()); + if (unionIndex447 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(447, null); + } else { + if (unionIndex447 == 1) { + Utf8 charSequence447; + Object oldString447 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(447); + if (oldString447 instanceof Utf8) { + charSequence447 = (decoder).readString(((Utf8) oldString447)); + } else { + charSequence447 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(447, charSequence447); + } else { + throw new RuntimeException(("Illegal union index for 'F447': "+ unionIndex447)); + } + } + int unionIndex448 = (decoder.readIndex()); + if (unionIndex448 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(448, null); + } else { + if (unionIndex448 == 1) { + Utf8 charSequence448; + Object oldString448 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(448); + if (oldString448 instanceof Utf8) { + charSequence448 = (decoder).readString(((Utf8) oldString448)); + } else { + charSequence448 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(448, charSequence448); + } else { + throw new RuntimeException(("Illegal union index for 'F448': "+ unionIndex448)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex449 = (decoder.readIndex()); + if (unionIndex449 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(449, null); + } else { + if (unionIndex449 == 1) { + Utf8 charSequence449; + Object oldString449 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(449); + if (oldString449 instanceof Utf8) { + charSequence449 = (decoder).readString(((Utf8) oldString449)); + } else { + charSequence449 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(449, charSequence449); + } else { + throw new RuntimeException(("Illegal union index for 'F449': "+ unionIndex449)); + } + } + int unionIndex450 = (decoder.readIndex()); + if (unionIndex450 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(450, null); + } else { + if (unionIndex450 == 1) { + Utf8 charSequence450; + Object oldString450 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(450); + if (oldString450 instanceof Utf8) { + charSequence450 = (decoder).readString(((Utf8) oldString450)); + } else { + charSequence450 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(450, charSequence450); + } else { + throw new RuntimeException(("Illegal union index for 'F450': "+ unionIndex450)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex451 = (decoder.readIndex()); + if (unionIndex451 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(451, null); + } else { + if (unionIndex451 == 1) { + Utf8 charSequence451; + Object oldString451 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(451); + if (oldString451 instanceof Utf8) { + charSequence451 = (decoder).readString(((Utf8) oldString451)); + } else { + charSequence451 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(451, charSequence451); + } else { + throw new RuntimeException(("Illegal union index for 'F451': "+ unionIndex451)); + } + } + int unionIndex452 = (decoder.readIndex()); + if (unionIndex452 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(452, null); + } else { + if (unionIndex452 == 1) { + Utf8 charSequence452; + Object oldString452 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(452); + if (oldString452 instanceof Utf8) { + charSequence452 = (decoder).readString(((Utf8) oldString452)); + } else { + charSequence452 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(452, charSequence452); + } else { + throw new RuntimeException(("Illegal union index for 'F452': "+ unionIndex452)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex453 = (decoder.readIndex()); + if (unionIndex453 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(453, null); + } else { + if (unionIndex453 == 1) { + Utf8 charSequence453; + Object oldString453 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(453); + if (oldString453 instanceof Utf8) { + charSequence453 = (decoder).readString(((Utf8) oldString453)); + } else { + charSequence453 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(453, charSequence453); + } else { + throw new RuntimeException(("Illegal union index for 'F453': "+ unionIndex453)); + } + } + int unionIndex454 = (decoder.readIndex()); + if (unionIndex454 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(454, null); + } else { + if (unionIndex454 == 1) { + Utf8 charSequence454; + Object oldString454 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(454); + if (oldString454 instanceof Utf8) { + charSequence454 = (decoder).readString(((Utf8) oldString454)); + } else { + charSequence454 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(454, charSequence454); + } else { + throw new RuntimeException(("Illegal union index for 'F454': "+ unionIndex454)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex455 = (decoder.readIndex()); + if (unionIndex455 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(455, null); + } else { + if (unionIndex455 == 1) { + Utf8 charSequence455; + Object oldString455 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(455); + if (oldString455 instanceof Utf8) { + charSequence455 = (decoder).readString(((Utf8) oldString455)); + } else { + charSequence455 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(455, charSequence455); + } else { + throw new RuntimeException(("Illegal union index for 'F455': "+ unionIndex455)); + } + } + int unionIndex456 = (decoder.readIndex()); + if (unionIndex456 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(456, null); + } else { + if (unionIndex456 == 1) { + Utf8 charSequence456; + Object oldString456 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(456); + if (oldString456 instanceof Utf8) { + charSequence456 = (decoder).readString(((Utf8) oldString456)); + } else { + charSequence456 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(456, charSequence456); + } else { + throw new RuntimeException(("Illegal union index for 'F456': "+ unionIndex456)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex457 = (decoder.readIndex()); + if (unionIndex457 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(457, null); + } else { + if (unionIndex457 == 1) { + Utf8 charSequence457; + Object oldString457 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(457); + if (oldString457 instanceof Utf8) { + charSequence457 = (decoder).readString(((Utf8) oldString457)); + } else { + charSequence457 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(457, charSequence457); + } else { + throw new RuntimeException(("Illegal union index for 'F457': "+ unionIndex457)); + } + } + int unionIndex458 = (decoder.readIndex()); + if (unionIndex458 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(458, null); + } else { + if (unionIndex458 == 1) { + Utf8 charSequence458; + Object oldString458 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(458); + if (oldString458 instanceof Utf8) { + charSequence458 = (decoder).readString(((Utf8) oldString458)); + } else { + charSequence458 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(458, charSequence458); + } else { + throw new RuntimeException(("Illegal union index for 'F458': "+ unionIndex458)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex459 = (decoder.readIndex()); + if (unionIndex459 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(459, null); + } else { + if (unionIndex459 == 1) { + Utf8 charSequence459; + Object oldString459 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(459); + if (oldString459 instanceof Utf8) { + charSequence459 = (decoder).readString(((Utf8) oldString459)); + } else { + charSequence459 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(459, charSequence459); + } else { + throw new RuntimeException(("Illegal union index for 'F459': "+ unionIndex459)); + } + } + int unionIndex460 = (decoder.readIndex()); + if (unionIndex460 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(460, null); + } else { + if (unionIndex460 == 1) { + Utf8 charSequence460; + Object oldString460 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(460); + if (oldString460 instanceof Utf8) { + charSequence460 = (decoder).readString(((Utf8) oldString460)); + } else { + charSequence460 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(460, charSequence460); + } else { + throw new RuntimeException(("Illegal union index for 'F460': "+ unionIndex460)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex461 = (decoder.readIndex()); + if (unionIndex461 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(461, null); + } else { + if (unionIndex461 == 1) { + Utf8 charSequence461; + Object oldString461 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(461); + if (oldString461 instanceof Utf8) { + charSequence461 = (decoder).readString(((Utf8) oldString461)); + } else { + charSequence461 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(461, charSequence461); + } else { + throw new RuntimeException(("Illegal union index for 'F461': "+ unionIndex461)); + } + } + int unionIndex462 = (decoder.readIndex()); + if (unionIndex462 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(462, null); + } else { + if (unionIndex462 == 1) { + Utf8 charSequence462; + Object oldString462 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(462); + if (oldString462 instanceof Utf8) { + charSequence462 = (decoder).readString(((Utf8) oldString462)); + } else { + charSequence462 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(462, charSequence462); + } else { + throw new RuntimeException(("Illegal union index for 'F462': "+ unionIndex462)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex463 = (decoder.readIndex()); + if (unionIndex463 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(463, null); + } else { + if (unionIndex463 == 1) { + Utf8 charSequence463; + Object oldString463 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(463); + if (oldString463 instanceof Utf8) { + charSequence463 = (decoder).readString(((Utf8) oldString463)); + } else { + charSequence463 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(463, charSequence463); + } else { + throw new RuntimeException(("Illegal union index for 'F463': "+ unionIndex463)); + } + } + int unionIndex464 = (decoder.readIndex()); + if (unionIndex464 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(464, null); + } else { + if (unionIndex464 == 1) { + Utf8 charSequence464; + Object oldString464 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(464); + if (oldString464 instanceof Utf8) { + charSequence464 = (decoder).readString(((Utf8) oldString464)); + } else { + charSequence464 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(464, charSequence464); + } else { + throw new RuntimeException(("Illegal union index for 'F464': "+ unionIndex464)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex465 = (decoder.readIndex()); + if (unionIndex465 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(465, null); + } else { + if (unionIndex465 == 1) { + Utf8 charSequence465; + Object oldString465 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(465); + if (oldString465 instanceof Utf8) { + charSequence465 = (decoder).readString(((Utf8) oldString465)); + } else { + charSequence465 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(465, charSequence465); + } else { + throw new RuntimeException(("Illegal union index for 'F465': "+ unionIndex465)); + } + } + int unionIndex466 = (decoder.readIndex()); + if (unionIndex466 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(466, null); + } else { + if (unionIndex466 == 1) { + Utf8 charSequence466; + Object oldString466 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(466); + if (oldString466 instanceof Utf8) { + charSequence466 = (decoder).readString(((Utf8) oldString466)); + } else { + charSequence466 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(466, charSequence466); + } else { + throw new RuntimeException(("Illegal union index for 'F466': "+ unionIndex466)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex467 = (decoder.readIndex()); + if (unionIndex467 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(467, null); + } else { + if (unionIndex467 == 1) { + Utf8 charSequence467; + Object oldString467 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(467); + if (oldString467 instanceof Utf8) { + charSequence467 = (decoder).readString(((Utf8) oldString467)); + } else { + charSequence467 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(467, charSequence467); + } else { + throw new RuntimeException(("Illegal union index for 'F467': "+ unionIndex467)); + } + } + int unionIndex468 = (decoder.readIndex()); + if (unionIndex468 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(468, null); + } else { + if (unionIndex468 == 1) { + Utf8 charSequence468; + Object oldString468 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(468); + if (oldString468 instanceof Utf8) { + charSequence468 = (decoder).readString(((Utf8) oldString468)); + } else { + charSequence468 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(468, charSequence468); + } else { + throw new RuntimeException(("Illegal union index for 'F468': "+ unionIndex468)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex469 = (decoder.readIndex()); + if (unionIndex469 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(469, null); + } else { + if (unionIndex469 == 1) { + Utf8 charSequence469; + Object oldString469 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(469); + if (oldString469 instanceof Utf8) { + charSequence469 = (decoder).readString(((Utf8) oldString469)); + } else { + charSequence469 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(469, charSequence469); + } else { + throw new RuntimeException(("Illegal union index for 'F469': "+ unionIndex469)); + } + } + int unionIndex470 = (decoder.readIndex()); + if (unionIndex470 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(470, null); + } else { + if (unionIndex470 == 1) { + Utf8 charSequence470; + Object oldString470 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(470); + if (oldString470 instanceof Utf8) { + charSequence470 = (decoder).readString(((Utf8) oldString470)); + } else { + charSequence470 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(470, charSequence470); + } else { + throw new RuntimeException(("Illegal union index for 'F470': "+ unionIndex470)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex471 = (decoder.readIndex()); + if (unionIndex471 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(471, null); + } else { + if (unionIndex471 == 1) { + Utf8 charSequence471; + Object oldString471 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(471); + if (oldString471 instanceof Utf8) { + charSequence471 = (decoder).readString(((Utf8) oldString471)); + } else { + charSequence471 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(471, charSequence471); + } else { + throw new RuntimeException(("Illegal union index for 'F471': "+ unionIndex471)); + } + } + int unionIndex472 = (decoder.readIndex()); + if (unionIndex472 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(472, null); + } else { + if (unionIndex472 == 1) { + Utf8 charSequence472; + Object oldString472 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(472); + if (oldString472 instanceof Utf8) { + charSequence472 = (decoder).readString(((Utf8) oldString472)); + } else { + charSequence472 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(472, charSequence472); + } else { + throw new RuntimeException(("Illegal union index for 'F472': "+ unionIndex472)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex473 = (decoder.readIndex()); + if (unionIndex473 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(473, null); + } else { + if (unionIndex473 == 1) { + Utf8 charSequence473; + Object oldString473 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(473); + if (oldString473 instanceof Utf8) { + charSequence473 = (decoder).readString(((Utf8) oldString473)); + } else { + charSequence473 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(473, charSequence473); + } else { + throw new RuntimeException(("Illegal union index for 'F473': "+ unionIndex473)); + } + } + int unionIndex474 = (decoder.readIndex()); + if (unionIndex474 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(474, null); + } else { + if (unionIndex474 == 1) { + Utf8 charSequence474; + Object oldString474 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(474); + if (oldString474 instanceof Utf8) { + charSequence474 = (decoder).readString(((Utf8) oldString474)); + } else { + charSequence474 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(474, charSequence474); + } else { + throw new RuntimeException(("Illegal union index for 'F474': "+ unionIndex474)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex475 = (decoder.readIndex()); + if (unionIndex475 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(475, null); + } else { + if (unionIndex475 == 1) { + Utf8 charSequence475; + Object oldString475 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(475); + if (oldString475 instanceof Utf8) { + charSequence475 = (decoder).readString(((Utf8) oldString475)); + } else { + charSequence475 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(475, charSequence475); + } else { + throw new RuntimeException(("Illegal union index for 'F475': "+ unionIndex475)); + } + } + int unionIndex476 = (decoder.readIndex()); + if (unionIndex476 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(476, null); + } else { + if (unionIndex476 == 1) { + Utf8 charSequence476; + Object oldString476 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(476); + if (oldString476 instanceof Utf8) { + charSequence476 = (decoder).readString(((Utf8) oldString476)); + } else { + charSequence476 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(476, charSequence476); + } else { + throw new RuntimeException(("Illegal union index for 'F476': "+ unionIndex476)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex477 = (decoder.readIndex()); + if (unionIndex477 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(477, null); + } else { + if (unionIndex477 == 1) { + Utf8 charSequence477; + Object oldString477 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(477); + if (oldString477 instanceof Utf8) { + charSequence477 = (decoder).readString(((Utf8) oldString477)); + } else { + charSequence477 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(477, charSequence477); + } else { + throw new RuntimeException(("Illegal union index for 'F477': "+ unionIndex477)); + } + } + int unionIndex478 = (decoder.readIndex()); + if (unionIndex478 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(478, null); + } else { + if (unionIndex478 == 1) { + Utf8 charSequence478; + Object oldString478 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(478); + if (oldString478 instanceof Utf8) { + charSequence478 = (decoder).readString(((Utf8) oldString478)); + } else { + charSequence478 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(478, charSequence478); + } else { + throw new RuntimeException(("Illegal union index for 'F478': "+ unionIndex478)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex479 = (decoder.readIndex()); + if (unionIndex479 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(479, null); + } else { + if (unionIndex479 == 1) { + Utf8 charSequence479; + Object oldString479 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(479); + if (oldString479 instanceof Utf8) { + charSequence479 = (decoder).readString(((Utf8) oldString479)); + } else { + charSequence479 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(479, charSequence479); + } else { + throw new RuntimeException(("Illegal union index for 'F479': "+ unionIndex479)); + } + } + int unionIndex480 = (decoder.readIndex()); + if (unionIndex480 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(480, null); + } else { + if (unionIndex480 == 1) { + Utf8 charSequence480; + Object oldString480 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(480); + if (oldString480 instanceof Utf8) { + charSequence480 = (decoder).readString(((Utf8) oldString480)); + } else { + charSequence480 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(480, charSequence480); + } else { + throw new RuntimeException(("Illegal union index for 'F480': "+ unionIndex480)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex481 = (decoder.readIndex()); + if (unionIndex481 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(481, null); + } else { + if (unionIndex481 == 1) { + Utf8 charSequence481; + Object oldString481 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(481); + if (oldString481 instanceof Utf8) { + charSequence481 = (decoder).readString(((Utf8) oldString481)); + } else { + charSequence481 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(481, charSequence481); + } else { + throw new RuntimeException(("Illegal union index for 'F481': "+ unionIndex481)); + } + } + int unionIndex482 = (decoder.readIndex()); + if (unionIndex482 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(482, null); + } else { + if (unionIndex482 == 1) { + Utf8 charSequence482; + Object oldString482 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(482); + if (oldString482 instanceof Utf8) { + charSequence482 = (decoder).readString(((Utf8) oldString482)); + } else { + charSequence482 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(482, charSequence482); + } else { + throw new RuntimeException(("Illegal union index for 'F482': "+ unionIndex482)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex483 = (decoder.readIndex()); + if (unionIndex483 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(483, null); + } else { + if (unionIndex483 == 1) { + Utf8 charSequence483; + Object oldString483 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(483); + if (oldString483 instanceof Utf8) { + charSequence483 = (decoder).readString(((Utf8) oldString483)); + } else { + charSequence483 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(483, charSequence483); + } else { + throw new RuntimeException(("Illegal union index for 'F483': "+ unionIndex483)); + } + } + int unionIndex484 = (decoder.readIndex()); + if (unionIndex484 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(484, null); + } else { + if (unionIndex484 == 1) { + Utf8 charSequence484; + Object oldString484 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(484); + if (oldString484 instanceof Utf8) { + charSequence484 = (decoder).readString(((Utf8) oldString484)); + } else { + charSequence484 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(484, charSequence484); + } else { + throw new RuntimeException(("Illegal union index for 'F484': "+ unionIndex484)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex485 = (decoder.readIndex()); + if (unionIndex485 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(485, null); + } else { + if (unionIndex485 == 1) { + Utf8 charSequence485; + Object oldString485 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(485); + if (oldString485 instanceof Utf8) { + charSequence485 = (decoder).readString(((Utf8) oldString485)); + } else { + charSequence485 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(485, charSequence485); + } else { + throw new RuntimeException(("Illegal union index for 'F485': "+ unionIndex485)); + } + } + int unionIndex486 = (decoder.readIndex()); + if (unionIndex486 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(486, null); + } else { + if (unionIndex486 == 1) { + Utf8 charSequence486; + Object oldString486 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(486); + if (oldString486 instanceof Utf8) { + charSequence486 = (decoder).readString(((Utf8) oldString486)); + } else { + charSequence486 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(486, charSequence486); + } else { + throw new RuntimeException(("Illegal union index for 'F486': "+ unionIndex486)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex487 = (decoder.readIndex()); + if (unionIndex487 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(487, null); + } else { + if (unionIndex487 == 1) { + Utf8 charSequence487; + Object oldString487 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(487); + if (oldString487 instanceof Utf8) { + charSequence487 = (decoder).readString(((Utf8) oldString487)); + } else { + charSequence487 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(487, charSequence487); + } else { + throw new RuntimeException(("Illegal union index for 'F487': "+ unionIndex487)); + } + } + int unionIndex488 = (decoder.readIndex()); + if (unionIndex488 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(488, null); + } else { + if (unionIndex488 == 1) { + Utf8 charSequence488; + Object oldString488 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(488); + if (oldString488 instanceof Utf8) { + charSequence488 = (decoder).readString(((Utf8) oldString488)); + } else { + charSequence488 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(488, charSequence488); + } else { + throw new RuntimeException(("Illegal union index for 'F488': "+ unionIndex488)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex489 = (decoder.readIndex()); + if (unionIndex489 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(489, null); + } else { + if (unionIndex489 == 1) { + Utf8 charSequence489; + Object oldString489 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(489); + if (oldString489 instanceof Utf8) { + charSequence489 = (decoder).readString(((Utf8) oldString489)); + } else { + charSequence489 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(489, charSequence489); + } else { + throw new RuntimeException(("Illegal union index for 'F489': "+ unionIndex489)); + } + } + int unionIndex490 = (decoder.readIndex()); + if (unionIndex490 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(490, null); + } else { + if (unionIndex490 == 1) { + Utf8 charSequence490; + Object oldString490 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(490); + if (oldString490 instanceof Utf8) { + charSequence490 = (decoder).readString(((Utf8) oldString490)); + } else { + charSequence490 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(490, charSequence490); + } else { + throw new RuntimeException(("Illegal union index for 'F490': "+ unionIndex490)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex491 = (decoder.readIndex()); + if (unionIndex491 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(491, null); + } else { + if (unionIndex491 == 1) { + Utf8 charSequence491; + Object oldString491 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(491); + if (oldString491 instanceof Utf8) { + charSequence491 = (decoder).readString(((Utf8) oldString491)); + } else { + charSequence491 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(491, charSequence491); + } else { + throw new RuntimeException(("Illegal union index for 'F491': "+ unionIndex491)); + } + } + int unionIndex492 = (decoder.readIndex()); + if (unionIndex492 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(492, null); + } else { + if (unionIndex492 == 1) { + Utf8 charSequence492; + Object oldString492 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(492); + if (oldString492 instanceof Utf8) { + charSequence492 = (decoder).readString(((Utf8) oldString492)); + } else { + charSequence492 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(492, charSequence492); + } else { + throw new RuntimeException(("Illegal union index for 'F492': "+ unionIndex492)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex493 = (decoder.readIndex()); + if (unionIndex493 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(493, null); + } else { + if (unionIndex493 == 1) { + Utf8 charSequence493; + Object oldString493 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(493); + if (oldString493 instanceof Utf8) { + charSequence493 = (decoder).readString(((Utf8) oldString493)); + } else { + charSequence493 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(493, charSequence493); + } else { + throw new RuntimeException(("Illegal union index for 'F493': "+ unionIndex493)); + } + } + int unionIndex494 = (decoder.readIndex()); + if (unionIndex494 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(494, null); + } else { + if (unionIndex494 == 1) { + Utf8 charSequence494; + Object oldString494 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(494); + if (oldString494 instanceof Utf8) { + charSequence494 = (decoder).readString(((Utf8) oldString494)); + } else { + charSequence494 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(494, charSequence494); + } else { + throw new RuntimeException(("Illegal union index for 'F494': "+ unionIndex494)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex495 = (decoder.readIndex()); + if (unionIndex495 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(495, null); + } else { + if (unionIndex495 == 1) { + Utf8 charSequence495; + Object oldString495 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(495); + if (oldString495 instanceof Utf8) { + charSequence495 = (decoder).readString(((Utf8) oldString495)); + } else { + charSequence495 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(495, charSequence495); + } else { + throw new RuntimeException(("Illegal union index for 'F495': "+ unionIndex495)); + } + } + int unionIndex496 = (decoder.readIndex()); + if (unionIndex496 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(496, null); + } else { + if (unionIndex496 == 1) { + Utf8 charSequence496; + Object oldString496 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(496); + if (oldString496 instanceof Utf8) { + charSequence496 = (decoder).readString(((Utf8) oldString496)); + } else { + charSequence496 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(496, charSequence496); + } else { + throw new RuntimeException(("Illegal union index for 'F496': "+ unionIndex496)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex497 = (decoder.readIndex()); + if (unionIndex497 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(497, null); + } else { + if (unionIndex497 == 1) { + Utf8 charSequence497; + Object oldString497 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(497); + if (oldString497 instanceof Utf8) { + charSequence497 = (decoder).readString(((Utf8) oldString497)); + } else { + charSequence497 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(497, charSequence497); + } else { + throw new RuntimeException(("Illegal union index for 'F497': "+ unionIndex497)); + } + } + int unionIndex498 = (decoder.readIndex()); + if (unionIndex498 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(498, null); + } else { + if (unionIndex498 == 1) { + Utf8 charSequence498; + Object oldString498 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(498); + if (oldString498 instanceof Utf8) { + charSequence498 = (decoder).readString(((Utf8) oldString498)); + } else { + charSequence498 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(498, charSequence498); + } else { + throw new RuntimeException(("Illegal union index for 'F498': "+ unionIndex498)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex499 = (decoder.readIndex()); + if (unionIndex499 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(499, null); + } else { + if (unionIndex499 == 1) { + Utf8 charSequence499; + Object oldString499 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(499); + if (oldString499 instanceof Utf8) { + charSequence499 = (decoder).readString(((Utf8) oldString499)); + } else { + charSequence499 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(499, charSequence499); + } else { + throw new RuntimeException(("Illegal union index for 'F499': "+ unionIndex499)); + } + } + int unionIndex500 = (decoder.readIndex()); + if (unionIndex500 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(500, null); + } else { + if (unionIndex500 == 1) { + Utf8 charSequence500; + Object oldString500 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(500); + if (oldString500 instanceof Utf8) { + charSequence500 = (decoder).readString(((Utf8) oldString500)); + } else { + charSequence500 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(500, charSequence500); + } else { + throw new RuntimeException(("Illegal union index for 'F500': "+ unionIndex500)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex501 = (decoder.readIndex()); + if (unionIndex501 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(501, null); + } else { + if (unionIndex501 == 1) { + Utf8 charSequence501; + Object oldString501 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(501); + if (oldString501 instanceof Utf8) { + charSequence501 = (decoder).readString(((Utf8) oldString501)); + } else { + charSequence501 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(501, charSequence501); + } else { + throw new RuntimeException(("Illegal union index for 'F501': "+ unionIndex501)); + } + } + int unionIndex502 = (decoder.readIndex()); + if (unionIndex502 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(502, null); + } else { + if (unionIndex502 == 1) { + Utf8 charSequence502; + Object oldString502 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(502); + if (oldString502 instanceof Utf8) { + charSequence502 = (decoder).readString(((Utf8) oldString502)); + } else { + charSequence502 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(502, charSequence502); + } else { + throw new RuntimeException(("Illegal union index for 'F502': "+ unionIndex502)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex503 = (decoder.readIndex()); + if (unionIndex503 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(503, null); + } else { + if (unionIndex503 == 1) { + Utf8 charSequence503; + Object oldString503 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(503); + if (oldString503 instanceof Utf8) { + charSequence503 = (decoder).readString(((Utf8) oldString503)); + } else { + charSequence503 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(503, charSequence503); + } else { + throw new RuntimeException(("Illegal union index for 'F503': "+ unionIndex503)); + } + } + int unionIndex504 = (decoder.readIndex()); + if (unionIndex504 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(504, null); + } else { + if (unionIndex504 == 1) { + Utf8 charSequence504; + Object oldString504 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(504); + if (oldString504 instanceof Utf8) { + charSequence504 = (decoder).readString(((Utf8) oldString504)); + } else { + charSequence504 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(504, charSequence504); + } else { + throw new RuntimeException(("Illegal union index for 'F504': "+ unionIndex504)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex505 = (decoder.readIndex()); + if (unionIndex505 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(505, null); + } else { + if (unionIndex505 == 1) { + Utf8 charSequence505; + Object oldString505 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(505); + if (oldString505 instanceof Utf8) { + charSequence505 = (decoder).readString(((Utf8) oldString505)); + } else { + charSequence505 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(505, charSequence505); + } else { + throw new RuntimeException(("Illegal union index for 'F505': "+ unionIndex505)); + } + } + int unionIndex506 = (decoder.readIndex()); + if (unionIndex506 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(506, null); + } else { + if (unionIndex506 == 1) { + Utf8 charSequence506; + Object oldString506 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(506); + if (oldString506 instanceof Utf8) { + charSequence506 = (decoder).readString(((Utf8) oldString506)); + } else { + charSequence506 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(506, charSequence506); + } else { + throw new RuntimeException(("Illegal union index for 'F506': "+ unionIndex506)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex507 = (decoder.readIndex()); + if (unionIndex507 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(507, null); + } else { + if (unionIndex507 == 1) { + Utf8 charSequence507; + Object oldString507 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(507); + if (oldString507 instanceof Utf8) { + charSequence507 = (decoder).readString(((Utf8) oldString507)); + } else { + charSequence507 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(507, charSequence507); + } else { + throw new RuntimeException(("Illegal union index for 'F507': "+ unionIndex507)); + } + } + int unionIndex508 = (decoder.readIndex()); + if (unionIndex508 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(508, null); + } else { + if (unionIndex508 == 1) { + Utf8 charSequence508; + Object oldString508 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(508); + if (oldString508 instanceof Utf8) { + charSequence508 = (decoder).readString(((Utf8) oldString508)); + } else { + charSequence508 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(508, charSequence508); + } else { + throw new RuntimeException(("Illegal union index for 'F508': "+ unionIndex508)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex509 = (decoder.readIndex()); + if (unionIndex509 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(509, null); + } else { + if (unionIndex509 == 1) { + Utf8 charSequence509; + Object oldString509 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(509); + if (oldString509 instanceof Utf8) { + charSequence509 = (decoder).readString(((Utf8) oldString509)); + } else { + charSequence509 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(509, charSequence509); + } else { + throw new RuntimeException(("Illegal union index for 'F509': "+ unionIndex509)); + } + } + int unionIndex510 = (decoder.readIndex()); + if (unionIndex510 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(510, null); + } else { + if (unionIndex510 == 1) { + Utf8 charSequence510; + Object oldString510 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(510); + if (oldString510 instanceof Utf8) { + charSequence510 = (decoder).readString(((Utf8) oldString510)); + } else { + charSequence510 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(510, charSequence510); + } else { + throw new RuntimeException(("Illegal union index for 'F510': "+ unionIndex510)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex511 = (decoder.readIndex()); + if (unionIndex511 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(511, null); + } else { + if (unionIndex511 == 1) { + Utf8 charSequence511; + Object oldString511 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(511); + if (oldString511 instanceof Utf8) { + charSequence511 = (decoder).readString(((Utf8) oldString511)); + } else { + charSequence511 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(511, charSequence511); + } else { + throw new RuntimeException(("Illegal union index for 'F511': "+ unionIndex511)); + } + } + int unionIndex512 = (decoder.readIndex()); + if (unionIndex512 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(512, null); + } else { + if (unionIndex512 == 1) { + Utf8 charSequence512; + Object oldString512 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(512); + if (oldString512 instanceof Utf8) { + charSequence512 = (decoder).readString(((Utf8) oldString512)); + } else { + charSequence512 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(512, charSequence512); + } else { + throw new RuntimeException(("Illegal union index for 'F512': "+ unionIndex512)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex513 = (decoder.readIndex()); + if (unionIndex513 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(513, null); + } else { + if (unionIndex513 == 1) { + Utf8 charSequence513; + Object oldString513 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(513); + if (oldString513 instanceof Utf8) { + charSequence513 = (decoder).readString(((Utf8) oldString513)); + } else { + charSequence513 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(513, charSequence513); + } else { + throw new RuntimeException(("Illegal union index for 'F513': "+ unionIndex513)); + } + } + int unionIndex514 = (decoder.readIndex()); + if (unionIndex514 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(514, null); + } else { + if (unionIndex514 == 1) { + Utf8 charSequence514; + Object oldString514 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(514); + if (oldString514 instanceof Utf8) { + charSequence514 = (decoder).readString(((Utf8) oldString514)); + } else { + charSequence514 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(514, charSequence514); + } else { + throw new RuntimeException(("Illegal union index for 'F514': "+ unionIndex514)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex515 = (decoder.readIndex()); + if (unionIndex515 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(515, null); + } else { + if (unionIndex515 == 1) { + Utf8 charSequence515; + Object oldString515 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(515); + if (oldString515 instanceof Utf8) { + charSequence515 = (decoder).readString(((Utf8) oldString515)); + } else { + charSequence515 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(515, charSequence515); + } else { + throw new RuntimeException(("Illegal union index for 'F515': "+ unionIndex515)); + } + } + int unionIndex516 = (decoder.readIndex()); + if (unionIndex516 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(516, null); + } else { + if (unionIndex516 == 1) { + Utf8 charSequence516; + Object oldString516 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(516); + if (oldString516 instanceof Utf8) { + charSequence516 = (decoder).readString(((Utf8) oldString516)); + } else { + charSequence516 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(516, charSequence516); + } else { + throw new RuntimeException(("Illegal union index for 'F516': "+ unionIndex516)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex517 = (decoder.readIndex()); + if (unionIndex517 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(517, null); + } else { + if (unionIndex517 == 1) { + Utf8 charSequence517; + Object oldString517 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(517); + if (oldString517 instanceof Utf8) { + charSequence517 = (decoder).readString(((Utf8) oldString517)); + } else { + charSequence517 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(517, charSequence517); + } else { + throw new RuntimeException(("Illegal union index for 'F517': "+ unionIndex517)); + } + } + int unionIndex518 = (decoder.readIndex()); + if (unionIndex518 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(518, null); + } else { + if (unionIndex518 == 1) { + Utf8 charSequence518; + Object oldString518 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(518); + if (oldString518 instanceof Utf8) { + charSequence518 = (decoder).readString(((Utf8) oldString518)); + } else { + charSequence518 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(518, charSequence518); + } else { + throw new RuntimeException(("Illegal union index for 'F518': "+ unionIndex518)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex519 = (decoder.readIndex()); + if (unionIndex519 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(519, null); + } else { + if (unionIndex519 == 1) { + Utf8 charSequence519; + Object oldString519 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(519); + if (oldString519 instanceof Utf8) { + charSequence519 = (decoder).readString(((Utf8) oldString519)); + } else { + charSequence519 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(519, charSequence519); + } else { + throw new RuntimeException(("Illegal union index for 'F519': "+ unionIndex519)); + } + } + int unionIndex520 = (decoder.readIndex()); + if (unionIndex520 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(520, null); + } else { + if (unionIndex520 == 1) { + Utf8 charSequence520; + Object oldString520 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(520); + if (oldString520 instanceof Utf8) { + charSequence520 = (decoder).readString(((Utf8) oldString520)); + } else { + charSequence520 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(520, charSequence520); + } else { + throw new RuntimeException(("Illegal union index for 'F520': "+ unionIndex520)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex521 = (decoder.readIndex()); + if (unionIndex521 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(521, null); + } else { + if (unionIndex521 == 1) { + Utf8 charSequence521; + Object oldString521 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(521); + if (oldString521 instanceof Utf8) { + charSequence521 = (decoder).readString(((Utf8) oldString521)); + } else { + charSequence521 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(521, charSequence521); + } else { + throw new RuntimeException(("Illegal union index for 'F521': "+ unionIndex521)); + } + } + int unionIndex522 = (decoder.readIndex()); + if (unionIndex522 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(522, null); + } else { + if (unionIndex522 == 1) { + Utf8 charSequence522; + Object oldString522 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(522); + if (oldString522 instanceof Utf8) { + charSequence522 = (decoder).readString(((Utf8) oldString522)); + } else { + charSequence522 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(522, charSequence522); + } else { + throw new RuntimeException(("Illegal union index for 'F522': "+ unionIndex522)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex523 = (decoder.readIndex()); + if (unionIndex523 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(523, null); + } else { + if (unionIndex523 == 1) { + Utf8 charSequence523; + Object oldString523 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(523); + if (oldString523 instanceof Utf8) { + charSequence523 = (decoder).readString(((Utf8) oldString523)); + } else { + charSequence523 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(523, charSequence523); + } else { + throw new RuntimeException(("Illegal union index for 'F523': "+ unionIndex523)); + } + } + int unionIndex524 = (decoder.readIndex()); + if (unionIndex524 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(524, null); + } else { + if (unionIndex524 == 1) { + Utf8 charSequence524; + Object oldString524 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(524); + if (oldString524 instanceof Utf8) { + charSequence524 = (decoder).readString(((Utf8) oldString524)); + } else { + charSequence524 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(524, charSequence524); + } else { + throw new RuntimeException(("Illegal union index for 'F524': "+ unionIndex524)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex525 = (decoder.readIndex()); + if (unionIndex525 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(525, null); + } else { + if (unionIndex525 == 1) { + Utf8 charSequence525; + Object oldString525 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(525); + if (oldString525 instanceof Utf8) { + charSequence525 = (decoder).readString(((Utf8) oldString525)); + } else { + charSequence525 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(525, charSequence525); + } else { + throw new RuntimeException(("Illegal union index for 'F525': "+ unionIndex525)); + } + } + int unionIndex526 = (decoder.readIndex()); + if (unionIndex526 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(526, null); + } else { + if (unionIndex526 == 1) { + Utf8 charSequence526; + Object oldString526 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(526); + if (oldString526 instanceof Utf8) { + charSequence526 = (decoder).readString(((Utf8) oldString526)); + } else { + charSequence526 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(526, charSequence526); + } else { + throw new RuntimeException(("Illegal union index for 'F526': "+ unionIndex526)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex527 = (decoder.readIndex()); + if (unionIndex527 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(527, null); + } else { + if (unionIndex527 == 1) { + Utf8 charSequence527; + Object oldString527 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(527); + if (oldString527 instanceof Utf8) { + charSequence527 = (decoder).readString(((Utf8) oldString527)); + } else { + charSequence527 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(527, charSequence527); + } else { + throw new RuntimeException(("Illegal union index for 'F527': "+ unionIndex527)); + } + } + int unionIndex528 = (decoder.readIndex()); + if (unionIndex528 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(528, null); + } else { + if (unionIndex528 == 1) { + Utf8 charSequence528; + Object oldString528 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(528); + if (oldString528 instanceof Utf8) { + charSequence528 = (decoder).readString(((Utf8) oldString528)); + } else { + charSequence528 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(528, charSequence528); + } else { + throw new RuntimeException(("Illegal union index for 'F528': "+ unionIndex528)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex529 = (decoder.readIndex()); + if (unionIndex529 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(529, null); + } else { + if (unionIndex529 == 1) { + Utf8 charSequence529; + Object oldString529 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(529); + if (oldString529 instanceof Utf8) { + charSequence529 = (decoder).readString(((Utf8) oldString529)); + } else { + charSequence529 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(529, charSequence529); + } else { + throw new RuntimeException(("Illegal union index for 'F529': "+ unionIndex529)); + } + } + int unionIndex530 = (decoder.readIndex()); + if (unionIndex530 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(530, null); + } else { + if (unionIndex530 == 1) { + Utf8 charSequence530; + Object oldString530 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(530); + if (oldString530 instanceof Utf8) { + charSequence530 = (decoder).readString(((Utf8) oldString530)); + } else { + charSequence530 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(530, charSequence530); + } else { + throw new RuntimeException(("Illegal union index for 'F530': "+ unionIndex530)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex531 = (decoder.readIndex()); + if (unionIndex531 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(531, null); + } else { + if (unionIndex531 == 1) { + Utf8 charSequence531; + Object oldString531 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(531); + if (oldString531 instanceof Utf8) { + charSequence531 = (decoder).readString(((Utf8) oldString531)); + } else { + charSequence531 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(531, charSequence531); + } else { + throw new RuntimeException(("Illegal union index for 'F531': "+ unionIndex531)); + } + } + int unionIndex532 = (decoder.readIndex()); + if (unionIndex532 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(532, null); + } else { + if (unionIndex532 == 1) { + Utf8 charSequence532; + Object oldString532 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(532); + if (oldString532 instanceof Utf8) { + charSequence532 = (decoder).readString(((Utf8) oldString532)); + } else { + charSequence532 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(532, charSequence532); + } else { + throw new RuntimeException(("Illegal union index for 'F532': "+ unionIndex532)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex533 = (decoder.readIndex()); + if (unionIndex533 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(533, null); + } else { + if (unionIndex533 == 1) { + Utf8 charSequence533; + Object oldString533 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(533); + if (oldString533 instanceof Utf8) { + charSequence533 = (decoder).readString(((Utf8) oldString533)); + } else { + charSequence533 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(533, charSequence533); + } else { + throw new RuntimeException(("Illegal union index for 'F533': "+ unionIndex533)); + } + } + int unionIndex534 = (decoder.readIndex()); + if (unionIndex534 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(534, null); + } else { + if (unionIndex534 == 1) { + Utf8 charSequence534; + Object oldString534 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(534); + if (oldString534 instanceof Utf8) { + charSequence534 = (decoder).readString(((Utf8) oldString534)); + } else { + charSequence534 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(534, charSequence534); + } else { + throw new RuntimeException(("Illegal union index for 'F534': "+ unionIndex534)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex535 = (decoder.readIndex()); + if (unionIndex535 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(535, null); + } else { + if (unionIndex535 == 1) { + Utf8 charSequence535; + Object oldString535 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(535); + if (oldString535 instanceof Utf8) { + charSequence535 = (decoder).readString(((Utf8) oldString535)); + } else { + charSequence535 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(535, charSequence535); + } else { + throw new RuntimeException(("Illegal union index for 'F535': "+ unionIndex535)); + } + } + int unionIndex536 = (decoder.readIndex()); + if (unionIndex536 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(536, null); + } else { + if (unionIndex536 == 1) { + Utf8 charSequence536; + Object oldString536 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(536); + if (oldString536 instanceof Utf8) { + charSequence536 = (decoder).readString(((Utf8) oldString536)); + } else { + charSequence536 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(536, charSequence536); + } else { + throw new RuntimeException(("Illegal union index for 'F536': "+ unionIndex536)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex537 = (decoder.readIndex()); + if (unionIndex537 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(537, null); + } else { + if (unionIndex537 == 1) { + Utf8 charSequence537; + Object oldString537 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(537); + if (oldString537 instanceof Utf8) { + charSequence537 = (decoder).readString(((Utf8) oldString537)); + } else { + charSequence537 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(537, charSequence537); + } else { + throw new RuntimeException(("Illegal union index for 'F537': "+ unionIndex537)); + } + } + int unionIndex538 = (decoder.readIndex()); + if (unionIndex538 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(538, null); + } else { + if (unionIndex538 == 1) { + Utf8 charSequence538; + Object oldString538 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(538); + if (oldString538 instanceof Utf8) { + charSequence538 = (decoder).readString(((Utf8) oldString538)); + } else { + charSequence538 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(538, charSequence538); + } else { + throw new RuntimeException(("Illegal union index for 'F538': "+ unionIndex538)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex539 = (decoder.readIndex()); + if (unionIndex539 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(539, null); + } else { + if (unionIndex539 == 1) { + Utf8 charSequence539; + Object oldString539 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(539); + if (oldString539 instanceof Utf8) { + charSequence539 = (decoder).readString(((Utf8) oldString539)); + } else { + charSequence539 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(539, charSequence539); + } else { + throw new RuntimeException(("Illegal union index for 'F539': "+ unionIndex539)); + } + } + int unionIndex540 = (decoder.readIndex()); + if (unionIndex540 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(540, null); + } else { + if (unionIndex540 == 1) { + Utf8 charSequence540; + Object oldString540 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(540); + if (oldString540 instanceof Utf8) { + charSequence540 = (decoder).readString(((Utf8) oldString540)); + } else { + charSequence540 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(540, charSequence540); + } else { + throw new RuntimeException(("Illegal union index for 'F540': "+ unionIndex540)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex541 = (decoder.readIndex()); + if (unionIndex541 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(541, null); + } else { + if (unionIndex541 == 1) { + Utf8 charSequence541; + Object oldString541 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(541); + if (oldString541 instanceof Utf8) { + charSequence541 = (decoder).readString(((Utf8) oldString541)); + } else { + charSequence541 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(541, charSequence541); + } else { + throw new RuntimeException(("Illegal union index for 'F541': "+ unionIndex541)); + } + } + int unionIndex542 = (decoder.readIndex()); + if (unionIndex542 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(542, null); + } else { + if (unionIndex542 == 1) { + Utf8 charSequence542; + Object oldString542 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(542); + if (oldString542 instanceof Utf8) { + charSequence542 = (decoder).readString(((Utf8) oldString542)); + } else { + charSequence542 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(542, charSequence542); + } else { + throw new RuntimeException(("Illegal union index for 'F542': "+ unionIndex542)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex543 = (decoder.readIndex()); + if (unionIndex543 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(543, null); + } else { + if (unionIndex543 == 1) { + Utf8 charSequence543; + Object oldString543 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(543); + if (oldString543 instanceof Utf8) { + charSequence543 = (decoder).readString(((Utf8) oldString543)); + } else { + charSequence543 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(543, charSequence543); + } else { + throw new RuntimeException(("Illegal union index for 'F543': "+ unionIndex543)); + } + } + int unionIndex544 = (decoder.readIndex()); + if (unionIndex544 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(544, null); + } else { + if (unionIndex544 == 1) { + Utf8 charSequence544; + Object oldString544 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(544); + if (oldString544 instanceof Utf8) { + charSequence544 = (decoder).readString(((Utf8) oldString544)); + } else { + charSequence544 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(544, charSequence544); + } else { + throw new RuntimeException(("Illegal union index for 'F544': "+ unionIndex544)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex545 = (decoder.readIndex()); + if (unionIndex545 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(545, null); + } else { + if (unionIndex545 == 1) { + Utf8 charSequence545; + Object oldString545 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(545); + if (oldString545 instanceof Utf8) { + charSequence545 = (decoder).readString(((Utf8) oldString545)); + } else { + charSequence545 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(545, charSequence545); + } else { + throw new RuntimeException(("Illegal union index for 'F545': "+ unionIndex545)); + } + } + int unionIndex546 = (decoder.readIndex()); + if (unionIndex546 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(546, null); + } else { + if (unionIndex546 == 1) { + Utf8 charSequence546; + Object oldString546 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(546); + if (oldString546 instanceof Utf8) { + charSequence546 = (decoder).readString(((Utf8) oldString546)); + } else { + charSequence546 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(546, charSequence546); + } else { + throw new RuntimeException(("Illegal union index for 'F546': "+ unionIndex546)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex547 = (decoder.readIndex()); + if (unionIndex547 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(547, null); + } else { + if (unionIndex547 == 1) { + Utf8 charSequence547; + Object oldString547 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(547); + if (oldString547 instanceof Utf8) { + charSequence547 = (decoder).readString(((Utf8) oldString547)); + } else { + charSequence547 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(547, charSequence547); + } else { + throw new RuntimeException(("Illegal union index for 'F547': "+ unionIndex547)); + } + } + int unionIndex548 = (decoder.readIndex()); + if (unionIndex548 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(548, null); + } else { + if (unionIndex548 == 1) { + Utf8 charSequence548; + Object oldString548 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(548); + if (oldString548 instanceof Utf8) { + charSequence548 = (decoder).readString(((Utf8) oldString548)); + } else { + charSequence548 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(548, charSequence548); + } else { + throw new RuntimeException(("Illegal union index for 'F548': "+ unionIndex548)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex549 = (decoder.readIndex()); + if (unionIndex549 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(549, null); + } else { + if (unionIndex549 == 1) { + Utf8 charSequence549; + Object oldString549 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(549); + if (oldString549 instanceof Utf8) { + charSequence549 = (decoder).readString(((Utf8) oldString549)); + } else { + charSequence549 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(549, charSequence549); + } else { + throw new RuntimeException(("Illegal union index for 'F549': "+ unionIndex549)); + } + } + int unionIndex550 = (decoder.readIndex()); + if (unionIndex550 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(550, null); + } else { + if (unionIndex550 == 1) { + Utf8 charSequence550; + Object oldString550 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(550); + if (oldString550 instanceof Utf8) { + charSequence550 = (decoder).readString(((Utf8) oldString550)); + } else { + charSequence550 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(550, charSequence550); + } else { + throw new RuntimeException(("Illegal union index for 'F550': "+ unionIndex550)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex551 = (decoder.readIndex()); + if (unionIndex551 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(551, null); + } else { + if (unionIndex551 == 1) { + Utf8 charSequence551; + Object oldString551 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(551); + if (oldString551 instanceof Utf8) { + charSequence551 = (decoder).readString(((Utf8) oldString551)); + } else { + charSequence551 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(551, charSequence551); + } else { + throw new RuntimeException(("Illegal union index for 'F551': "+ unionIndex551)); + } + } + int unionIndex552 = (decoder.readIndex()); + if (unionIndex552 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(552, null); + } else { + if (unionIndex552 == 1) { + Utf8 charSequence552; + Object oldString552 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(552); + if (oldString552 instanceof Utf8) { + charSequence552 = (decoder).readString(((Utf8) oldString552)); + } else { + charSequence552 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(552, charSequence552); + } else { + throw new RuntimeException(("Illegal union index for 'F552': "+ unionIndex552)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex553 = (decoder.readIndex()); + if (unionIndex553 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(553, null); + } else { + if (unionIndex553 == 1) { + Utf8 charSequence553; + Object oldString553 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(553); + if (oldString553 instanceof Utf8) { + charSequence553 = (decoder).readString(((Utf8) oldString553)); + } else { + charSequence553 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(553, charSequence553); + } else { + throw new RuntimeException(("Illegal union index for 'F553': "+ unionIndex553)); + } + } + int unionIndex554 = (decoder.readIndex()); + if (unionIndex554 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(554, null); + } else { + if (unionIndex554 == 1) { + Utf8 charSequence554; + Object oldString554 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(554); + if (oldString554 instanceof Utf8) { + charSequence554 = (decoder).readString(((Utf8) oldString554)); + } else { + charSequence554 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(554, charSequence554); + } else { + throw new RuntimeException(("Illegal union index for 'F554': "+ unionIndex554)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex555 = (decoder.readIndex()); + if (unionIndex555 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(555, null); + } else { + if (unionIndex555 == 1) { + Utf8 charSequence555; + Object oldString555 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(555); + if (oldString555 instanceof Utf8) { + charSequence555 = (decoder).readString(((Utf8) oldString555)); + } else { + charSequence555 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(555, charSequence555); + } else { + throw new RuntimeException(("Illegal union index for 'F555': "+ unionIndex555)); + } + } + int unionIndex556 = (decoder.readIndex()); + if (unionIndex556 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(556, null); + } else { + if (unionIndex556 == 1) { + Utf8 charSequence556; + Object oldString556 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(556); + if (oldString556 instanceof Utf8) { + charSequence556 = (decoder).readString(((Utf8) oldString556)); + } else { + charSequence556 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(556, charSequence556); + } else { + throw new RuntimeException(("Illegal union index for 'F556': "+ unionIndex556)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex557 = (decoder.readIndex()); + if (unionIndex557 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(557, null); + } else { + if (unionIndex557 == 1) { + Utf8 charSequence557; + Object oldString557 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(557); + if (oldString557 instanceof Utf8) { + charSequence557 = (decoder).readString(((Utf8) oldString557)); + } else { + charSequence557 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(557, charSequence557); + } else { + throw new RuntimeException(("Illegal union index for 'F557': "+ unionIndex557)); + } + } + int unionIndex558 = (decoder.readIndex()); + if (unionIndex558 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(558, null); + } else { + if (unionIndex558 == 1) { + Utf8 charSequence558; + Object oldString558 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(558); + if (oldString558 instanceof Utf8) { + charSequence558 = (decoder).readString(((Utf8) oldString558)); + } else { + charSequence558 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(558, charSequence558); + } else { + throw new RuntimeException(("Illegal union index for 'F558': "+ unionIndex558)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex559 = (decoder.readIndex()); + if (unionIndex559 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(559, null); + } else { + if (unionIndex559 == 1) { + Utf8 charSequence559; + Object oldString559 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(559); + if (oldString559 instanceof Utf8) { + charSequence559 = (decoder).readString(((Utf8) oldString559)); + } else { + charSequence559 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(559, charSequence559); + } else { + throw new RuntimeException(("Illegal union index for 'F559': "+ unionIndex559)); + } + } + int unionIndex560 = (decoder.readIndex()); + if (unionIndex560 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(560, null); + } else { + if (unionIndex560 == 1) { + Utf8 charSequence560; + Object oldString560 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(560); + if (oldString560 instanceof Utf8) { + charSequence560 = (decoder).readString(((Utf8) oldString560)); + } else { + charSequence560 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(560, charSequence560); + } else { + throw new RuntimeException(("Illegal union index for 'F560': "+ unionIndex560)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex561 = (decoder.readIndex()); + if (unionIndex561 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(561, null); + } else { + if (unionIndex561 == 1) { + Utf8 charSequence561; + Object oldString561 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(561); + if (oldString561 instanceof Utf8) { + charSequence561 = (decoder).readString(((Utf8) oldString561)); + } else { + charSequence561 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(561, charSequence561); + } else { + throw new RuntimeException(("Illegal union index for 'F561': "+ unionIndex561)); + } + } + int unionIndex562 = (decoder.readIndex()); + if (unionIndex562 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(562, null); + } else { + if (unionIndex562 == 1) { + Utf8 charSequence562; + Object oldString562 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(562); + if (oldString562 instanceof Utf8) { + charSequence562 = (decoder).readString(((Utf8) oldString562)); + } else { + charSequence562 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(562, charSequence562); + } else { + throw new RuntimeException(("Illegal union index for 'F562': "+ unionIndex562)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex563 = (decoder.readIndex()); + if (unionIndex563 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(563, null); + } else { + if (unionIndex563 == 1) { + Utf8 charSequence563; + Object oldString563 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(563); + if (oldString563 instanceof Utf8) { + charSequence563 = (decoder).readString(((Utf8) oldString563)); + } else { + charSequence563 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(563, charSequence563); + } else { + throw new RuntimeException(("Illegal union index for 'F563': "+ unionIndex563)); + } + } + int unionIndex564 = (decoder.readIndex()); + if (unionIndex564 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(564, null); + } else { + if (unionIndex564 == 1) { + Utf8 charSequence564; + Object oldString564 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(564); + if (oldString564 instanceof Utf8) { + charSequence564 = (decoder).readString(((Utf8) oldString564)); + } else { + charSequence564 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(564, charSequence564); + } else { + throw new RuntimeException(("Illegal union index for 'F564': "+ unionIndex564)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex565 = (decoder.readIndex()); + if (unionIndex565 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(565, null); + } else { + if (unionIndex565 == 1) { + Utf8 charSequence565; + Object oldString565 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(565); + if (oldString565 instanceof Utf8) { + charSequence565 = (decoder).readString(((Utf8) oldString565)); + } else { + charSequence565 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(565, charSequence565); + } else { + throw new RuntimeException(("Illegal union index for 'F565': "+ unionIndex565)); + } + } + int unionIndex566 = (decoder.readIndex()); + if (unionIndex566 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(566, null); + } else { + if (unionIndex566 == 1) { + Utf8 charSequence566; + Object oldString566 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(566); + if (oldString566 instanceof Utf8) { + charSequence566 = (decoder).readString(((Utf8) oldString566)); + } else { + charSequence566 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(566, charSequence566); + } else { + throw new RuntimeException(("Illegal union index for 'F566': "+ unionIndex566)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex567 = (decoder.readIndex()); + if (unionIndex567 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(567, null); + } else { + if (unionIndex567 == 1) { + Utf8 charSequence567; + Object oldString567 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(567); + if (oldString567 instanceof Utf8) { + charSequence567 = (decoder).readString(((Utf8) oldString567)); + } else { + charSequence567 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(567, charSequence567); + } else { + throw new RuntimeException(("Illegal union index for 'F567': "+ unionIndex567)); + } + } + int unionIndex568 = (decoder.readIndex()); + if (unionIndex568 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(568, null); + } else { + if (unionIndex568 == 1) { + Utf8 charSequence568; + Object oldString568 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(568); + if (oldString568 instanceof Utf8) { + charSequence568 = (decoder).readString(((Utf8) oldString568)); + } else { + charSequence568 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(568, charSequence568); + } else { + throw new RuntimeException(("Illegal union index for 'F568': "+ unionIndex568)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex569 = (decoder.readIndex()); + if (unionIndex569 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(569, null); + } else { + if (unionIndex569 == 1) { + Utf8 charSequence569; + Object oldString569 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(569); + if (oldString569 instanceof Utf8) { + charSequence569 = (decoder).readString(((Utf8) oldString569)); + } else { + charSequence569 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(569, charSequence569); + } else { + throw new RuntimeException(("Illegal union index for 'F569': "+ unionIndex569)); + } + } + int unionIndex570 = (decoder.readIndex()); + if (unionIndex570 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(570, null); + } else { + if (unionIndex570 == 1) { + Utf8 charSequence570; + Object oldString570 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(570); + if (oldString570 instanceof Utf8) { + charSequence570 = (decoder).readString(((Utf8) oldString570)); + } else { + charSequence570 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(570, charSequence570); + } else { + throw new RuntimeException(("Illegal union index for 'F570': "+ unionIndex570)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex571 = (decoder.readIndex()); + if (unionIndex571 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(571, null); + } else { + if (unionIndex571 == 1) { + Utf8 charSequence571; + Object oldString571 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(571); + if (oldString571 instanceof Utf8) { + charSequence571 = (decoder).readString(((Utf8) oldString571)); + } else { + charSequence571 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(571, charSequence571); + } else { + throw new RuntimeException(("Illegal union index for 'F571': "+ unionIndex571)); + } + } + int unionIndex572 = (decoder.readIndex()); + if (unionIndex572 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(572, null); + } else { + if (unionIndex572 == 1) { + Utf8 charSequence572; + Object oldString572 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(572); + if (oldString572 instanceof Utf8) { + charSequence572 = (decoder).readString(((Utf8) oldString572)); + } else { + charSequence572 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(572, charSequence572); + } else { + throw new RuntimeException(("Illegal union index for 'F572': "+ unionIndex572)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex573 = (decoder.readIndex()); + if (unionIndex573 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(573, null); + } else { + if (unionIndex573 == 1) { + Utf8 charSequence573; + Object oldString573 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(573); + if (oldString573 instanceof Utf8) { + charSequence573 = (decoder).readString(((Utf8) oldString573)); + } else { + charSequence573 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(573, charSequence573); + } else { + throw new RuntimeException(("Illegal union index for 'F573': "+ unionIndex573)); + } + } + int unionIndex574 = (decoder.readIndex()); + if (unionIndex574 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(574, null); + } else { + if (unionIndex574 == 1) { + Utf8 charSequence574; + Object oldString574 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(574); + if (oldString574 instanceof Utf8) { + charSequence574 = (decoder).readString(((Utf8) oldString574)); + } else { + charSequence574 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(574, charSequence574); + } else { + throw new RuntimeException(("Illegal union index for 'F574': "+ unionIndex574)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex575 = (decoder.readIndex()); + if (unionIndex575 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(575, null); + } else { + if (unionIndex575 == 1) { + Utf8 charSequence575; + Object oldString575 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(575); + if (oldString575 instanceof Utf8) { + charSequence575 = (decoder).readString(((Utf8) oldString575)); + } else { + charSequence575 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(575, charSequence575); + } else { + throw new RuntimeException(("Illegal union index for 'F575': "+ unionIndex575)); + } + } + int unionIndex576 = (decoder.readIndex()); + if (unionIndex576 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(576, null); + } else { + if (unionIndex576 == 1) { + Utf8 charSequence576; + Object oldString576 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(576); + if (oldString576 instanceof Utf8) { + charSequence576 = (decoder).readString(((Utf8) oldString576)); + } else { + charSequence576 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(576, charSequence576); + } else { + throw new RuntimeException(("Illegal union index for 'F576': "+ unionIndex576)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex577 = (decoder.readIndex()); + if (unionIndex577 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(577, null); + } else { + if (unionIndex577 == 1) { + Utf8 charSequence577; + Object oldString577 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(577); + if (oldString577 instanceof Utf8) { + charSequence577 = (decoder).readString(((Utf8) oldString577)); + } else { + charSequence577 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(577, charSequence577); + } else { + throw new RuntimeException(("Illegal union index for 'F577': "+ unionIndex577)); + } + } + int unionIndex578 = (decoder.readIndex()); + if (unionIndex578 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(578, null); + } else { + if (unionIndex578 == 1) { + Utf8 charSequence578; + Object oldString578 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(578); + if (oldString578 instanceof Utf8) { + charSequence578 = (decoder).readString(((Utf8) oldString578)); + } else { + charSequence578 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(578, charSequence578); + } else { + throw new RuntimeException(("Illegal union index for 'F578': "+ unionIndex578)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex579 = (decoder.readIndex()); + if (unionIndex579 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(579, null); + } else { + if (unionIndex579 == 1) { + Utf8 charSequence579; + Object oldString579 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(579); + if (oldString579 instanceof Utf8) { + charSequence579 = (decoder).readString(((Utf8) oldString579)); + } else { + charSequence579 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(579, charSequence579); + } else { + throw new RuntimeException(("Illegal union index for 'F579': "+ unionIndex579)); + } + } + int unionIndex580 = (decoder.readIndex()); + if (unionIndex580 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(580, null); + } else { + if (unionIndex580 == 1) { + Utf8 charSequence580; + Object oldString580 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(580); + if (oldString580 instanceof Utf8) { + charSequence580 = (decoder).readString(((Utf8) oldString580)); + } else { + charSequence580 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(580, charSequence580); + } else { + throw new RuntimeException(("Illegal union index for 'F580': "+ unionIndex580)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex581 = (decoder.readIndex()); + if (unionIndex581 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(581, null); + } else { + if (unionIndex581 == 1) { + Utf8 charSequence581; + Object oldString581 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(581); + if (oldString581 instanceof Utf8) { + charSequence581 = (decoder).readString(((Utf8) oldString581)); + } else { + charSequence581 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(581, charSequence581); + } else { + throw new RuntimeException(("Illegal union index for 'F581': "+ unionIndex581)); + } + } + int unionIndex582 = (decoder.readIndex()); + if (unionIndex582 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(582, null); + } else { + if (unionIndex582 == 1) { + Utf8 charSequence582; + Object oldString582 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(582); + if (oldString582 instanceof Utf8) { + charSequence582 = (decoder).readString(((Utf8) oldString582)); + } else { + charSequence582 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(582, charSequence582); + } else { + throw new RuntimeException(("Illegal union index for 'F582': "+ unionIndex582)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex583 = (decoder.readIndex()); + if (unionIndex583 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(583, null); + } else { + if (unionIndex583 == 1) { + Utf8 charSequence583; + Object oldString583 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(583); + if (oldString583 instanceof Utf8) { + charSequence583 = (decoder).readString(((Utf8) oldString583)); + } else { + charSequence583 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(583, charSequence583); + } else { + throw new RuntimeException(("Illegal union index for 'F583': "+ unionIndex583)); + } + } + int unionIndex584 = (decoder.readIndex()); + if (unionIndex584 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(584, null); + } else { + if (unionIndex584 == 1) { + Utf8 charSequence584; + Object oldString584 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(584); + if (oldString584 instanceof Utf8) { + charSequence584 = (decoder).readString(((Utf8) oldString584)); + } else { + charSequence584 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(584, charSequence584); + } else { + throw new RuntimeException(("Illegal union index for 'F584': "+ unionIndex584)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex585 = (decoder.readIndex()); + if (unionIndex585 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(585, null); + } else { + if (unionIndex585 == 1) { + Utf8 charSequence585; + Object oldString585 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(585); + if (oldString585 instanceof Utf8) { + charSequence585 = (decoder).readString(((Utf8) oldString585)); + } else { + charSequence585 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(585, charSequence585); + } else { + throw new RuntimeException(("Illegal union index for 'F585': "+ unionIndex585)); + } + } + int unionIndex586 = (decoder.readIndex()); + if (unionIndex586 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(586, null); + } else { + if (unionIndex586 == 1) { + Utf8 charSequence586; + Object oldString586 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(586); + if (oldString586 instanceof Utf8) { + charSequence586 = (decoder).readString(((Utf8) oldString586)); + } else { + charSequence586 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(586, charSequence586); + } else { + throw new RuntimeException(("Illegal union index for 'F586': "+ unionIndex586)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex587 = (decoder.readIndex()); + if (unionIndex587 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(587, null); + } else { + if (unionIndex587 == 1) { + Utf8 charSequence587; + Object oldString587 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(587); + if (oldString587 instanceof Utf8) { + charSequence587 = (decoder).readString(((Utf8) oldString587)); + } else { + charSequence587 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(587, charSequence587); + } else { + throw new RuntimeException(("Illegal union index for 'F587': "+ unionIndex587)); + } + } + int unionIndex588 = (decoder.readIndex()); + if (unionIndex588 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(588, null); + } else { + if (unionIndex588 == 1) { + Utf8 charSequence588; + Object oldString588 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(588); + if (oldString588 instanceof Utf8) { + charSequence588 = (decoder).readString(((Utf8) oldString588)); + } else { + charSequence588 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(588, charSequence588); + } else { + throw new RuntimeException(("Illegal union index for 'F588': "+ unionIndex588)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex589 = (decoder.readIndex()); + if (unionIndex589 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(589, null); + } else { + if (unionIndex589 == 1) { + Utf8 charSequence589; + Object oldString589 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(589); + if (oldString589 instanceof Utf8) { + charSequence589 = (decoder).readString(((Utf8) oldString589)); + } else { + charSequence589 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(589, charSequence589); + } else { + throw new RuntimeException(("Illegal union index for 'F589': "+ unionIndex589)); + } + } + int unionIndex590 = (decoder.readIndex()); + if (unionIndex590 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(590, null); + } else { + if (unionIndex590 == 1) { + Utf8 charSequence590; + Object oldString590 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(590); + if (oldString590 instanceof Utf8) { + charSequence590 = (decoder).readString(((Utf8) oldString590)); + } else { + charSequence590 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(590, charSequence590); + } else { + throw new RuntimeException(("Illegal union index for 'F590': "+ unionIndex590)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex591 = (decoder.readIndex()); + if (unionIndex591 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(591, null); + } else { + if (unionIndex591 == 1) { + Utf8 charSequence591; + Object oldString591 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(591); + if (oldString591 instanceof Utf8) { + charSequence591 = (decoder).readString(((Utf8) oldString591)); + } else { + charSequence591 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(591, charSequence591); + } else { + throw new RuntimeException(("Illegal union index for 'F591': "+ unionIndex591)); + } + } + int unionIndex592 = (decoder.readIndex()); + if (unionIndex592 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(592, null); + } else { + if (unionIndex592 == 1) { + Utf8 charSequence592; + Object oldString592 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(592); + if (oldString592 instanceof Utf8) { + charSequence592 = (decoder).readString(((Utf8) oldString592)); + } else { + charSequence592 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(592, charSequence592); + } else { + throw new RuntimeException(("Illegal union index for 'F592': "+ unionIndex592)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex593 = (decoder.readIndex()); + if (unionIndex593 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(593, null); + } else { + if (unionIndex593 == 1) { + Utf8 charSequence593; + Object oldString593 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(593); + if (oldString593 instanceof Utf8) { + charSequence593 = (decoder).readString(((Utf8) oldString593)); + } else { + charSequence593 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(593, charSequence593); + } else { + throw new RuntimeException(("Illegal union index for 'F593': "+ unionIndex593)); + } + } + int unionIndex594 = (decoder.readIndex()); + if (unionIndex594 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(594, null); + } else { + if (unionIndex594 == 1) { + Utf8 charSequence594; + Object oldString594 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(594); + if (oldString594 instanceof Utf8) { + charSequence594 = (decoder).readString(((Utf8) oldString594)); + } else { + charSequence594 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(594, charSequence594); + } else { + throw new RuntimeException(("Illegal union index for 'F594': "+ unionIndex594)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex595 = (decoder.readIndex()); + if (unionIndex595 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(595, null); + } else { + if (unionIndex595 == 1) { + Utf8 charSequence595; + Object oldString595 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(595); + if (oldString595 instanceof Utf8) { + charSequence595 = (decoder).readString(((Utf8) oldString595)); + } else { + charSequence595 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(595, charSequence595); + } else { + throw new RuntimeException(("Illegal union index for 'F595': "+ unionIndex595)); + } + } + int unionIndex596 = (decoder.readIndex()); + if (unionIndex596 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(596, null); + } else { + if (unionIndex596 == 1) { + Utf8 charSequence596; + Object oldString596 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(596); + if (oldString596 instanceof Utf8) { + charSequence596 = (decoder).readString(((Utf8) oldString596)); + } else { + charSequence596 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(596, charSequence596); + } else { + throw new RuntimeException(("Illegal union index for 'F596': "+ unionIndex596)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex597 = (decoder.readIndex()); + if (unionIndex597 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(597, null); + } else { + if (unionIndex597 == 1) { + Utf8 charSequence597; + Object oldString597 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(597); + if (oldString597 instanceof Utf8) { + charSequence597 = (decoder).readString(((Utf8) oldString597)); + } else { + charSequence597 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(597, charSequence597); + } else { + throw new RuntimeException(("Illegal union index for 'F597': "+ unionIndex597)); + } + } + int unionIndex598 = (decoder.readIndex()); + if (unionIndex598 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(598, null); + } else { + if (unionIndex598 == 1) { + Utf8 charSequence598; + Object oldString598 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(598); + if (oldString598 instanceof Utf8) { + charSequence598 = (decoder).readString(((Utf8) oldString598)); + } else { + charSequence598 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(598, charSequence598); + } else { + throw new RuntimeException(("Illegal union index for 'F598': "+ unionIndex598)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex599 = (decoder.readIndex()); + if (unionIndex599 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(599, null); + } else { + if (unionIndex599 == 1) { + Utf8 charSequence599; + Object oldString599 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(599); + if (oldString599 instanceof Utf8) { + charSequence599 = (decoder).readString(((Utf8) oldString599)); + } else { + charSequence599 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(599, charSequence599); + } else { + throw new RuntimeException(("Illegal union index for 'F599': "+ unionIndex599)); + } + } + int unionIndex600 = (decoder.readIndex()); + if (unionIndex600 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(600, null); + } else { + if (unionIndex600 == 1) { + Utf8 charSequence600; + Object oldString600 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(600); + if (oldString600 instanceof Utf8) { + charSequence600 = (decoder).readString(((Utf8) oldString600)); + } else { + charSequence600 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(600, charSequence600); + } else { + throw new RuntimeException(("Illegal union index for 'F600': "+ unionIndex600)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex601 = (decoder.readIndex()); + if (unionIndex601 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(601, null); + } else { + if (unionIndex601 == 1) { + Utf8 charSequence601; + Object oldString601 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(601); + if (oldString601 instanceof Utf8) { + charSequence601 = (decoder).readString(((Utf8) oldString601)); + } else { + charSequence601 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(601, charSequence601); + } else { + throw new RuntimeException(("Illegal union index for 'F601': "+ unionIndex601)); + } + } + int unionIndex602 = (decoder.readIndex()); + if (unionIndex602 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(602, null); + } else { + if (unionIndex602 == 1) { + Utf8 charSequence602; + Object oldString602 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(602); + if (oldString602 instanceof Utf8) { + charSequence602 = (decoder).readString(((Utf8) oldString602)); + } else { + charSequence602 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(602, charSequence602); + } else { + throw new RuntimeException(("Illegal union index for 'F602': "+ unionIndex602)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex603 = (decoder.readIndex()); + if (unionIndex603 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(603, null); + } else { + if (unionIndex603 == 1) { + Utf8 charSequence603; + Object oldString603 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(603); + if (oldString603 instanceof Utf8) { + charSequence603 = (decoder).readString(((Utf8) oldString603)); + } else { + charSequence603 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(603, charSequence603); + } else { + throw new RuntimeException(("Illegal union index for 'F603': "+ unionIndex603)); + } + } + int unionIndex604 = (decoder.readIndex()); + if (unionIndex604 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(604, null); + } else { + if (unionIndex604 == 1) { + Utf8 charSequence604; + Object oldString604 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(604); + if (oldString604 instanceof Utf8) { + charSequence604 = (decoder).readString(((Utf8) oldString604)); + } else { + charSequence604 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(604, charSequence604); + } else { + throw new RuntimeException(("Illegal union index for 'F604': "+ unionIndex604)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex605 = (decoder.readIndex()); + if (unionIndex605 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(605, null); + } else { + if (unionIndex605 == 1) { + Utf8 charSequence605; + Object oldString605 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(605); + if (oldString605 instanceof Utf8) { + charSequence605 = (decoder).readString(((Utf8) oldString605)); + } else { + charSequence605 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(605, charSequence605); + } else { + throw new RuntimeException(("Illegal union index for 'F605': "+ unionIndex605)); + } + } + int unionIndex606 = (decoder.readIndex()); + if (unionIndex606 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(606, null); + } else { + if (unionIndex606 == 1) { + Utf8 charSequence606; + Object oldString606 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(606); + if (oldString606 instanceof Utf8) { + charSequence606 = (decoder).readString(((Utf8) oldString606)); + } else { + charSequence606 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(606, charSequence606); + } else { + throw new RuntimeException(("Illegal union index for 'F606': "+ unionIndex606)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex607 = (decoder.readIndex()); + if (unionIndex607 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(607, null); + } else { + if (unionIndex607 == 1) { + Utf8 charSequence607; + Object oldString607 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(607); + if (oldString607 instanceof Utf8) { + charSequence607 = (decoder).readString(((Utf8) oldString607)); + } else { + charSequence607 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(607, charSequence607); + } else { + throw new RuntimeException(("Illegal union index for 'F607': "+ unionIndex607)); + } + } + int unionIndex608 = (decoder.readIndex()); + if (unionIndex608 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(608, null); + } else { + if (unionIndex608 == 1) { + Utf8 charSequence608; + Object oldString608 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(608); + if (oldString608 instanceof Utf8) { + charSequence608 = (decoder).readString(((Utf8) oldString608)); + } else { + charSequence608 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(608, charSequence608); + } else { + throw new RuntimeException(("Illegal union index for 'F608': "+ unionIndex608)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex609 = (decoder.readIndex()); + if (unionIndex609 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(609, null); + } else { + if (unionIndex609 == 1) { + Utf8 charSequence609; + Object oldString609 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(609); + if (oldString609 instanceof Utf8) { + charSequence609 = (decoder).readString(((Utf8) oldString609)); + } else { + charSequence609 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(609, charSequence609); + } else { + throw new RuntimeException(("Illegal union index for 'F609': "+ unionIndex609)); + } + } + int unionIndex610 = (decoder.readIndex()); + if (unionIndex610 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(610, null); + } else { + if (unionIndex610 == 1) { + Utf8 charSequence610; + Object oldString610 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(610); + if (oldString610 instanceof Utf8) { + charSequence610 = (decoder).readString(((Utf8) oldString610)); + } else { + charSequence610 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(610, charSequence610); + } else { + throw new RuntimeException(("Illegal union index for 'F610': "+ unionIndex610)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex611 = (decoder.readIndex()); + if (unionIndex611 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(611, null); + } else { + if (unionIndex611 == 1) { + Utf8 charSequence611; + Object oldString611 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(611); + if (oldString611 instanceof Utf8) { + charSequence611 = (decoder).readString(((Utf8) oldString611)); + } else { + charSequence611 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(611, charSequence611); + } else { + throw new RuntimeException(("Illegal union index for 'F611': "+ unionIndex611)); + } + } + int unionIndex612 = (decoder.readIndex()); + if (unionIndex612 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(612, null); + } else { + if (unionIndex612 == 1) { + Utf8 charSequence612; + Object oldString612 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(612); + if (oldString612 instanceof Utf8) { + charSequence612 = (decoder).readString(((Utf8) oldString612)); + } else { + charSequence612 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(612, charSequence612); + } else { + throw new RuntimeException(("Illegal union index for 'F612': "+ unionIndex612)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex613 = (decoder.readIndex()); + if (unionIndex613 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(613, null); + } else { + if (unionIndex613 == 1) { + Utf8 charSequence613; + Object oldString613 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(613); + if (oldString613 instanceof Utf8) { + charSequence613 = (decoder).readString(((Utf8) oldString613)); + } else { + charSequence613 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(613, charSequence613); + } else { + throw new RuntimeException(("Illegal union index for 'F613': "+ unionIndex613)); + } + } + int unionIndex614 = (decoder.readIndex()); + if (unionIndex614 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(614, null); + } else { + if (unionIndex614 == 1) { + Utf8 charSequence614; + Object oldString614 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(614); + if (oldString614 instanceof Utf8) { + charSequence614 = (decoder).readString(((Utf8) oldString614)); + } else { + charSequence614 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(614, charSequence614); + } else { + throw new RuntimeException(("Illegal union index for 'F614': "+ unionIndex614)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex615 = (decoder.readIndex()); + if (unionIndex615 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(615, null); + } else { + if (unionIndex615 == 1) { + Utf8 charSequence615; + Object oldString615 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(615); + if (oldString615 instanceof Utf8) { + charSequence615 = (decoder).readString(((Utf8) oldString615)); + } else { + charSequence615 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(615, charSequence615); + } else { + throw new RuntimeException(("Illegal union index for 'F615': "+ unionIndex615)); + } + } + int unionIndex616 = (decoder.readIndex()); + if (unionIndex616 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(616, null); + } else { + if (unionIndex616 == 1) { + Utf8 charSequence616; + Object oldString616 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(616); + if (oldString616 instanceof Utf8) { + charSequence616 = (decoder).readString(((Utf8) oldString616)); + } else { + charSequence616 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(616, charSequence616); + } else { + throw new RuntimeException(("Illegal union index for 'F616': "+ unionIndex616)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex617 = (decoder.readIndex()); + if (unionIndex617 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(617, null); + } else { + if (unionIndex617 == 1) { + Utf8 charSequence617; + Object oldString617 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(617); + if (oldString617 instanceof Utf8) { + charSequence617 = (decoder).readString(((Utf8) oldString617)); + } else { + charSequence617 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(617, charSequence617); + } else { + throw new RuntimeException(("Illegal union index for 'F617': "+ unionIndex617)); + } + } + int unionIndex618 = (decoder.readIndex()); + if (unionIndex618 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(618, null); + } else { + if (unionIndex618 == 1) { + Utf8 charSequence618; + Object oldString618 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(618); + if (oldString618 instanceof Utf8) { + charSequence618 = (decoder).readString(((Utf8) oldString618)); + } else { + charSequence618 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(618, charSequence618); + } else { + throw new RuntimeException(("Illegal union index for 'F618': "+ unionIndex618)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex619 = (decoder.readIndex()); + if (unionIndex619 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(619, null); + } else { + if (unionIndex619 == 1) { + Utf8 charSequence619; + Object oldString619 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(619); + if (oldString619 instanceof Utf8) { + charSequence619 = (decoder).readString(((Utf8) oldString619)); + } else { + charSequence619 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(619, charSequence619); + } else { + throw new RuntimeException(("Illegal union index for 'F619': "+ unionIndex619)); + } + } + int unionIndex620 = (decoder.readIndex()); + if (unionIndex620 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(620, null); + } else { + if (unionIndex620 == 1) { + Utf8 charSequence620; + Object oldString620 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(620); + if (oldString620 instanceof Utf8) { + charSequence620 = (decoder).readString(((Utf8) oldString620)); + } else { + charSequence620 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(620, charSequence620); + } else { + throw new RuntimeException(("Illegal union index for 'F620': "+ unionIndex620)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex621 = (decoder.readIndex()); + if (unionIndex621 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(621, null); + } else { + if (unionIndex621 == 1) { + Utf8 charSequence621; + Object oldString621 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(621); + if (oldString621 instanceof Utf8) { + charSequence621 = (decoder).readString(((Utf8) oldString621)); + } else { + charSequence621 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(621, charSequence621); + } else { + throw new RuntimeException(("Illegal union index for 'F621': "+ unionIndex621)); + } + } + int unionIndex622 = (decoder.readIndex()); + if (unionIndex622 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(622, null); + } else { + if (unionIndex622 == 1) { + Utf8 charSequence622; + Object oldString622 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(622); + if (oldString622 instanceof Utf8) { + charSequence622 = (decoder).readString(((Utf8) oldString622)); + } else { + charSequence622 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(622, charSequence622); + } else { + throw new RuntimeException(("Illegal union index for 'F622': "+ unionIndex622)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex623 = (decoder.readIndex()); + if (unionIndex623 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(623, null); + } else { + if (unionIndex623 == 1) { + Utf8 charSequence623; + Object oldString623 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(623); + if (oldString623 instanceof Utf8) { + charSequence623 = (decoder).readString(((Utf8) oldString623)); + } else { + charSequence623 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(623, charSequence623); + } else { + throw new RuntimeException(("Illegal union index for 'F623': "+ unionIndex623)); + } + } + int unionIndex624 = (decoder.readIndex()); + if (unionIndex624 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(624, null); + } else { + if (unionIndex624 == 1) { + Utf8 charSequence624; + Object oldString624 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(624); + if (oldString624 instanceof Utf8) { + charSequence624 = (decoder).readString(((Utf8) oldString624)); + } else { + charSequence624 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(624, charSequence624); + } else { + throw new RuntimeException(("Illegal union index for 'F624': "+ unionIndex624)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex625 = (decoder.readIndex()); + if (unionIndex625 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(625, null); + } else { + if (unionIndex625 == 1) { + Utf8 charSequence625; + Object oldString625 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(625); + if (oldString625 instanceof Utf8) { + charSequence625 = (decoder).readString(((Utf8) oldString625)); + } else { + charSequence625 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(625, charSequence625); + } else { + throw new RuntimeException(("Illegal union index for 'F625': "+ unionIndex625)); + } + } + int unionIndex626 = (decoder.readIndex()); + if (unionIndex626 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(626, null); + } else { + if (unionIndex626 == 1) { + Utf8 charSequence626; + Object oldString626 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(626); + if (oldString626 instanceof Utf8) { + charSequence626 = (decoder).readString(((Utf8) oldString626)); + } else { + charSequence626 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(626, charSequence626); + } else { + throw new RuntimeException(("Illegal union index for 'F626': "+ unionIndex626)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex627 = (decoder.readIndex()); + if (unionIndex627 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(627, null); + } else { + if (unionIndex627 == 1) { + Utf8 charSequence627; + Object oldString627 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(627); + if (oldString627 instanceof Utf8) { + charSequence627 = (decoder).readString(((Utf8) oldString627)); + } else { + charSequence627 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(627, charSequence627); + } else { + throw new RuntimeException(("Illegal union index for 'F627': "+ unionIndex627)); + } + } + int unionIndex628 = (decoder.readIndex()); + if (unionIndex628 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(628, null); + } else { + if (unionIndex628 == 1) { + Utf8 charSequence628; + Object oldString628 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(628); + if (oldString628 instanceof Utf8) { + charSequence628 = (decoder).readString(((Utf8) oldString628)); + } else { + charSequence628 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(628, charSequence628); + } else { + throw new RuntimeException(("Illegal union index for 'F628': "+ unionIndex628)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex629 = (decoder.readIndex()); + if (unionIndex629 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(629, null); + } else { + if (unionIndex629 == 1) { + Utf8 charSequence629; + Object oldString629 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(629); + if (oldString629 instanceof Utf8) { + charSequence629 = (decoder).readString(((Utf8) oldString629)); + } else { + charSequence629 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(629, charSequence629); + } else { + throw new RuntimeException(("Illegal union index for 'F629': "+ unionIndex629)); + } + } + int unionIndex630 = (decoder.readIndex()); + if (unionIndex630 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(630, null); + } else { + if (unionIndex630 == 1) { + Utf8 charSequence630; + Object oldString630 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(630); + if (oldString630 instanceof Utf8) { + charSequence630 = (decoder).readString(((Utf8) oldString630)); + } else { + charSequence630 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(630, charSequence630); + } else { + throw new RuntimeException(("Illegal union index for 'F630': "+ unionIndex630)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex631 = (decoder.readIndex()); + if (unionIndex631 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(631, null); + } else { + if (unionIndex631 == 1) { + Utf8 charSequence631; + Object oldString631 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(631); + if (oldString631 instanceof Utf8) { + charSequence631 = (decoder).readString(((Utf8) oldString631)); + } else { + charSequence631 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(631, charSequence631); + } else { + throw new RuntimeException(("Illegal union index for 'F631': "+ unionIndex631)); + } + } + int unionIndex632 = (decoder.readIndex()); + if (unionIndex632 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(632, null); + } else { + if (unionIndex632 == 1) { + Utf8 charSequence632; + Object oldString632 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(632); + if (oldString632 instanceof Utf8) { + charSequence632 = (decoder).readString(((Utf8) oldString632)); + } else { + charSequence632 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(632, charSequence632); + } else { + throw new RuntimeException(("Illegal union index for 'F632': "+ unionIndex632)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex633 = (decoder.readIndex()); + if (unionIndex633 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(633, null); + } else { + if (unionIndex633 == 1) { + Utf8 charSequence633; + Object oldString633 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(633); + if (oldString633 instanceof Utf8) { + charSequence633 = (decoder).readString(((Utf8) oldString633)); + } else { + charSequence633 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(633, charSequence633); + } else { + throw new RuntimeException(("Illegal union index for 'F633': "+ unionIndex633)); + } + } + int unionIndex634 = (decoder.readIndex()); + if (unionIndex634 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(634, null); + } else { + if (unionIndex634 == 1) { + Utf8 charSequence634; + Object oldString634 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(634); + if (oldString634 instanceof Utf8) { + charSequence634 = (decoder).readString(((Utf8) oldString634)); + } else { + charSequence634 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(634, charSequence634); + } else { + throw new RuntimeException(("Illegal union index for 'F634': "+ unionIndex634)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex635 = (decoder.readIndex()); + if (unionIndex635 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(635, null); + } else { + if (unionIndex635 == 1) { + Utf8 charSequence635; + Object oldString635 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(635); + if (oldString635 instanceof Utf8) { + charSequence635 = (decoder).readString(((Utf8) oldString635)); + } else { + charSequence635 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(635, charSequence635); + } else { + throw new RuntimeException(("Illegal union index for 'F635': "+ unionIndex635)); + } + } + int unionIndex636 = (decoder.readIndex()); + if (unionIndex636 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(636, null); + } else { + if (unionIndex636 == 1) { + Utf8 charSequence636; + Object oldString636 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(636); + if (oldString636 instanceof Utf8) { + charSequence636 = (decoder).readString(((Utf8) oldString636)); + } else { + charSequence636 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(636, charSequence636); + } else { + throw new RuntimeException(("Illegal union index for 'F636': "+ unionIndex636)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex637 = (decoder.readIndex()); + if (unionIndex637 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(637, null); + } else { + if (unionIndex637 == 1) { + Utf8 charSequence637; + Object oldString637 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(637); + if (oldString637 instanceof Utf8) { + charSequence637 = (decoder).readString(((Utf8) oldString637)); + } else { + charSequence637 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(637, charSequence637); + } else { + throw new RuntimeException(("Illegal union index for 'F637': "+ unionIndex637)); + } + } + int unionIndex638 = (decoder.readIndex()); + if (unionIndex638 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(638, null); + } else { + if (unionIndex638 == 1) { + Utf8 charSequence638; + Object oldString638 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(638); + if (oldString638 instanceof Utf8) { + charSequence638 = (decoder).readString(((Utf8) oldString638)); + } else { + charSequence638 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(638, charSequence638); + } else { + throw new RuntimeException(("Illegal union index for 'F638': "+ unionIndex638)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex639 = (decoder.readIndex()); + if (unionIndex639 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(639, null); + } else { + if (unionIndex639 == 1) { + Utf8 charSequence639; + Object oldString639 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(639); + if (oldString639 instanceof Utf8) { + charSequence639 = (decoder).readString(((Utf8) oldString639)); + } else { + charSequence639 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(639, charSequence639); + } else { + throw new RuntimeException(("Illegal union index for 'F639': "+ unionIndex639)); + } + } + int unionIndex640 = (decoder.readIndex()); + if (unionIndex640 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(640, null); + } else { + if (unionIndex640 == 1) { + Utf8 charSequence640; + Object oldString640 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(640); + if (oldString640 instanceof Utf8) { + charSequence640 = (decoder).readString(((Utf8) oldString640)); + } else { + charSequence640 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(640, charSequence640); + } else { + throw new RuntimeException(("Illegal union index for 'F640': "+ unionIndex640)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex641 = (decoder.readIndex()); + if (unionIndex641 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(641, null); + } else { + if (unionIndex641 == 1) { + Utf8 charSequence641; + Object oldString641 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(641); + if (oldString641 instanceof Utf8) { + charSequence641 = (decoder).readString(((Utf8) oldString641)); + } else { + charSequence641 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(641, charSequence641); + } else { + throw new RuntimeException(("Illegal union index for 'F641': "+ unionIndex641)); + } + } + int unionIndex642 = (decoder.readIndex()); + if (unionIndex642 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(642, null); + } else { + if (unionIndex642 == 1) { + Utf8 charSequence642; + Object oldString642 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(642); + if (oldString642 instanceof Utf8) { + charSequence642 = (decoder).readString(((Utf8) oldString642)); + } else { + charSequence642 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(642, charSequence642); + } else { + throw new RuntimeException(("Illegal union index for 'F642': "+ unionIndex642)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex643 = (decoder.readIndex()); + if (unionIndex643 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(643, null); + } else { + if (unionIndex643 == 1) { + Utf8 charSequence643; + Object oldString643 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(643); + if (oldString643 instanceof Utf8) { + charSequence643 = (decoder).readString(((Utf8) oldString643)); + } else { + charSequence643 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(643, charSequence643); + } else { + throw new RuntimeException(("Illegal union index for 'F643': "+ unionIndex643)); + } + } + int unionIndex644 = (decoder.readIndex()); + if (unionIndex644 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(644, null); + } else { + if (unionIndex644 == 1) { + Utf8 charSequence644; + Object oldString644 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(644); + if (oldString644 instanceof Utf8) { + charSequence644 = (decoder).readString(((Utf8) oldString644)); + } else { + charSequence644 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(644, charSequence644); + } else { + throw new RuntimeException(("Illegal union index for 'F644': "+ unionIndex644)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex645 = (decoder.readIndex()); + if (unionIndex645 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(645, null); + } else { + if (unionIndex645 == 1) { + Utf8 charSequence645; + Object oldString645 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(645); + if (oldString645 instanceof Utf8) { + charSequence645 = (decoder).readString(((Utf8) oldString645)); + } else { + charSequence645 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(645, charSequence645); + } else { + throw new RuntimeException(("Illegal union index for 'F645': "+ unionIndex645)); + } + } + int unionIndex646 = (decoder.readIndex()); + if (unionIndex646 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(646, null); + } else { + if (unionIndex646 == 1) { + Utf8 charSequence646; + Object oldString646 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(646); + if (oldString646 instanceof Utf8) { + charSequence646 = (decoder).readString(((Utf8) oldString646)); + } else { + charSequence646 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(646, charSequence646); + } else { + throw new RuntimeException(("Illegal union index for 'F646': "+ unionIndex646)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex647 = (decoder.readIndex()); + if (unionIndex647 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(647, null); + } else { + if (unionIndex647 == 1) { + Utf8 charSequence647; + Object oldString647 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(647); + if (oldString647 instanceof Utf8) { + charSequence647 = (decoder).readString(((Utf8) oldString647)); + } else { + charSequence647 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(647, charSequence647); + } else { + throw new RuntimeException(("Illegal union index for 'F647': "+ unionIndex647)); + } + } + int unionIndex648 = (decoder.readIndex()); + if (unionIndex648 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(648, null); + } else { + if (unionIndex648 == 1) { + Utf8 charSequence648; + Object oldString648 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(648); + if (oldString648 instanceof Utf8) { + charSequence648 = (decoder).readString(((Utf8) oldString648)); + } else { + charSequence648 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(648, charSequence648); + } else { + throw new RuntimeException(("Illegal union index for 'F648': "+ unionIndex648)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex649 = (decoder.readIndex()); + if (unionIndex649 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(649, null); + } else { + if (unionIndex649 == 1) { + Utf8 charSequence649; + Object oldString649 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(649); + if (oldString649 instanceof Utf8) { + charSequence649 = (decoder).readString(((Utf8) oldString649)); + } else { + charSequence649 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(649, charSequence649); + } else { + throw new RuntimeException(("Illegal union index for 'F649': "+ unionIndex649)); + } + } + int unionIndex650 = (decoder.readIndex()); + if (unionIndex650 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(650, null); + } else { + if (unionIndex650 == 1) { + Utf8 charSequence650; + Object oldString650 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(650); + if (oldString650 instanceof Utf8) { + charSequence650 = (decoder).readString(((Utf8) oldString650)); + } else { + charSequence650 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(650, charSequence650); + } else { + throw new RuntimeException(("Illegal union index for 'F650': "+ unionIndex650)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex651 = (decoder.readIndex()); + if (unionIndex651 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(651, null); + } else { + if (unionIndex651 == 1) { + Utf8 charSequence651; + Object oldString651 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(651); + if (oldString651 instanceof Utf8) { + charSequence651 = (decoder).readString(((Utf8) oldString651)); + } else { + charSequence651 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(651, charSequence651); + } else { + throw new RuntimeException(("Illegal union index for 'F651': "+ unionIndex651)); + } + } + int unionIndex652 = (decoder.readIndex()); + if (unionIndex652 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(652, null); + } else { + if (unionIndex652 == 1) { + Utf8 charSequence652; + Object oldString652 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(652); + if (oldString652 instanceof Utf8) { + charSequence652 = (decoder).readString(((Utf8) oldString652)); + } else { + charSequence652 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(652, charSequence652); + } else { + throw new RuntimeException(("Illegal union index for 'F652': "+ unionIndex652)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex653 = (decoder.readIndex()); + if (unionIndex653 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(653, null); + } else { + if (unionIndex653 == 1) { + Utf8 charSequence653; + Object oldString653 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(653); + if (oldString653 instanceof Utf8) { + charSequence653 = (decoder).readString(((Utf8) oldString653)); + } else { + charSequence653 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(653, charSequence653); + } else { + throw new RuntimeException(("Illegal union index for 'F653': "+ unionIndex653)); + } + } + int unionIndex654 = (decoder.readIndex()); + if (unionIndex654 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(654, null); + } else { + if (unionIndex654 == 1) { + Utf8 charSequence654; + Object oldString654 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(654); + if (oldString654 instanceof Utf8) { + charSequence654 = (decoder).readString(((Utf8) oldString654)); + } else { + charSequence654 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(654, charSequence654); + } else { + throw new RuntimeException(("Illegal union index for 'F654': "+ unionIndex654)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex655 = (decoder.readIndex()); + if (unionIndex655 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(655, null); + } else { + if (unionIndex655 == 1) { + Utf8 charSequence655; + Object oldString655 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(655); + if (oldString655 instanceof Utf8) { + charSequence655 = (decoder).readString(((Utf8) oldString655)); + } else { + charSequence655 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(655, charSequence655); + } else { + throw new RuntimeException(("Illegal union index for 'F655': "+ unionIndex655)); + } + } + int unionIndex656 = (decoder.readIndex()); + if (unionIndex656 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(656, null); + } else { + if (unionIndex656 == 1) { + Utf8 charSequence656; + Object oldString656 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(656); + if (oldString656 instanceof Utf8) { + charSequence656 = (decoder).readString(((Utf8) oldString656)); + } else { + charSequence656 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(656, charSequence656); + } else { + throw new RuntimeException(("Illegal union index for 'F656': "+ unionIndex656)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex657 = (decoder.readIndex()); + if (unionIndex657 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(657, null); + } else { + if (unionIndex657 == 1) { + Utf8 charSequence657; + Object oldString657 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(657); + if (oldString657 instanceof Utf8) { + charSequence657 = (decoder).readString(((Utf8) oldString657)); + } else { + charSequence657 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(657, charSequence657); + } else { + throw new RuntimeException(("Illegal union index for 'F657': "+ unionIndex657)); + } + } + int unionIndex658 = (decoder.readIndex()); + if (unionIndex658 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(658, null); + } else { + if (unionIndex658 == 1) { + Utf8 charSequence658; + Object oldString658 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(658); + if (oldString658 instanceof Utf8) { + charSequence658 = (decoder).readString(((Utf8) oldString658)); + } else { + charSequence658 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(658, charSequence658); + } else { + throw new RuntimeException(("Illegal union index for 'F658': "+ unionIndex658)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex659 = (decoder.readIndex()); + if (unionIndex659 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(659, null); + } else { + if (unionIndex659 == 1) { + Utf8 charSequence659; + Object oldString659 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(659); + if (oldString659 instanceof Utf8) { + charSequence659 = (decoder).readString(((Utf8) oldString659)); + } else { + charSequence659 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(659, charSequence659); + } else { + throw new RuntimeException(("Illegal union index for 'F659': "+ unionIndex659)); + } + } + int unionIndex660 = (decoder.readIndex()); + if (unionIndex660 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(660, null); + } else { + if (unionIndex660 == 1) { + Utf8 charSequence660; + Object oldString660 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(660); + if (oldString660 instanceof Utf8) { + charSequence660 = (decoder).readString(((Utf8) oldString660)); + } else { + charSequence660 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(660, charSequence660); + } else { + throw new RuntimeException(("Illegal union index for 'F660': "+ unionIndex660)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex661 = (decoder.readIndex()); + if (unionIndex661 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(661, null); + } else { + if (unionIndex661 == 1) { + Utf8 charSequence661; + Object oldString661 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(661); + if (oldString661 instanceof Utf8) { + charSequence661 = (decoder).readString(((Utf8) oldString661)); + } else { + charSequence661 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(661, charSequence661); + } else { + throw new RuntimeException(("Illegal union index for 'F661': "+ unionIndex661)); + } + } + int unionIndex662 = (decoder.readIndex()); + if (unionIndex662 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(662, null); + } else { + if (unionIndex662 == 1) { + Utf8 charSequence662; + Object oldString662 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(662); + if (oldString662 instanceof Utf8) { + charSequence662 = (decoder).readString(((Utf8) oldString662)); + } else { + charSequence662 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(662, charSequence662); + } else { + throw new RuntimeException(("Illegal union index for 'F662': "+ unionIndex662)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex663 = (decoder.readIndex()); + if (unionIndex663 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(663, null); + } else { + if (unionIndex663 == 1) { + Utf8 charSequence663; + Object oldString663 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(663); + if (oldString663 instanceof Utf8) { + charSequence663 = (decoder).readString(((Utf8) oldString663)); + } else { + charSequence663 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(663, charSequence663); + } else { + throw new RuntimeException(("Illegal union index for 'F663': "+ unionIndex663)); + } + } + int unionIndex664 = (decoder.readIndex()); + if (unionIndex664 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(664, null); + } else { + if (unionIndex664 == 1) { + Utf8 charSequence664; + Object oldString664 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(664); + if (oldString664 instanceof Utf8) { + charSequence664 = (decoder).readString(((Utf8) oldString664)); + } else { + charSequence664 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(664, charSequence664); + } else { + throw new RuntimeException(("Illegal union index for 'F664': "+ unionIndex664)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex665 = (decoder.readIndex()); + if (unionIndex665 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(665, null); + } else { + if (unionIndex665 == 1) { + Utf8 charSequence665; + Object oldString665 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(665); + if (oldString665 instanceof Utf8) { + charSequence665 = (decoder).readString(((Utf8) oldString665)); + } else { + charSequence665 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(665, charSequence665); + } else { + throw new RuntimeException(("Illegal union index for 'F665': "+ unionIndex665)); + } + } + int unionIndex666 = (decoder.readIndex()); + if (unionIndex666 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(666, null); + } else { + if (unionIndex666 == 1) { + Utf8 charSequence666; + Object oldString666 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(666); + if (oldString666 instanceof Utf8) { + charSequence666 = (decoder).readString(((Utf8) oldString666)); + } else { + charSequence666 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(666, charSequence666); + } else { + throw new RuntimeException(("Illegal union index for 'F666': "+ unionIndex666)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex667 = (decoder.readIndex()); + if (unionIndex667 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(667, null); + } else { + if (unionIndex667 == 1) { + Utf8 charSequence667; + Object oldString667 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(667); + if (oldString667 instanceof Utf8) { + charSequence667 = (decoder).readString(((Utf8) oldString667)); + } else { + charSequence667 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(667, charSequence667); + } else { + throw new RuntimeException(("Illegal union index for 'F667': "+ unionIndex667)); + } + } + int unionIndex668 = (decoder.readIndex()); + if (unionIndex668 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(668, null); + } else { + if (unionIndex668 == 1) { + Utf8 charSequence668; + Object oldString668 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(668); + if (oldString668 instanceof Utf8) { + charSequence668 = (decoder).readString(((Utf8) oldString668)); + } else { + charSequence668 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(668, charSequence668); + } else { + throw new RuntimeException(("Illegal union index for 'F668': "+ unionIndex668)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex669 = (decoder.readIndex()); + if (unionIndex669 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(669, null); + } else { + if (unionIndex669 == 1) { + Utf8 charSequence669; + Object oldString669 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(669); + if (oldString669 instanceof Utf8) { + charSequence669 = (decoder).readString(((Utf8) oldString669)); + } else { + charSequence669 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(669, charSequence669); + } else { + throw new RuntimeException(("Illegal union index for 'F669': "+ unionIndex669)); + } + } + int unionIndex670 = (decoder.readIndex()); + if (unionIndex670 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(670, null); + } else { + if (unionIndex670 == 1) { + Utf8 charSequence670; + Object oldString670 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(670); + if (oldString670 instanceof Utf8) { + charSequence670 = (decoder).readString(((Utf8) oldString670)); + } else { + charSequence670 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(670, charSequence670); + } else { + throw new RuntimeException(("Illegal union index for 'F670': "+ unionIndex670)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex671 = (decoder.readIndex()); + if (unionIndex671 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(671, null); + } else { + if (unionIndex671 == 1) { + Utf8 charSequence671; + Object oldString671 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(671); + if (oldString671 instanceof Utf8) { + charSequence671 = (decoder).readString(((Utf8) oldString671)); + } else { + charSequence671 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(671, charSequence671); + } else { + throw new RuntimeException(("Illegal union index for 'F671': "+ unionIndex671)); + } + } + int unionIndex672 = (decoder.readIndex()); + if (unionIndex672 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(672, null); + } else { + if (unionIndex672 == 1) { + Utf8 charSequence672; + Object oldString672 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(672); + if (oldString672 instanceof Utf8) { + charSequence672 = (decoder).readString(((Utf8) oldString672)); + } else { + charSequence672 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(672, charSequence672); + } else { + throw new RuntimeException(("Illegal union index for 'F672': "+ unionIndex672)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex673 = (decoder.readIndex()); + if (unionIndex673 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(673, null); + } else { + if (unionIndex673 == 1) { + Utf8 charSequence673; + Object oldString673 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(673); + if (oldString673 instanceof Utf8) { + charSequence673 = (decoder).readString(((Utf8) oldString673)); + } else { + charSequence673 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(673, charSequence673); + } else { + throw new RuntimeException(("Illegal union index for 'F673': "+ unionIndex673)); + } + } + int unionIndex674 = (decoder.readIndex()); + if (unionIndex674 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(674, null); + } else { + if (unionIndex674 == 1) { + Utf8 charSequence674; + Object oldString674 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(674); + if (oldString674 instanceof Utf8) { + charSequence674 = (decoder).readString(((Utf8) oldString674)); + } else { + charSequence674 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(674, charSequence674); + } else { + throw new RuntimeException(("Illegal union index for 'F674': "+ unionIndex674)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex675 = (decoder.readIndex()); + if (unionIndex675 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(675, null); + } else { + if (unionIndex675 == 1) { + Utf8 charSequence675; + Object oldString675 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(675); + if (oldString675 instanceof Utf8) { + charSequence675 = (decoder).readString(((Utf8) oldString675)); + } else { + charSequence675 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(675, charSequence675); + } else { + throw new RuntimeException(("Illegal union index for 'F675': "+ unionIndex675)); + } + } + int unionIndex676 = (decoder.readIndex()); + if (unionIndex676 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(676, null); + } else { + if (unionIndex676 == 1) { + Utf8 charSequence676; + Object oldString676 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(676); + if (oldString676 instanceof Utf8) { + charSequence676 = (decoder).readString(((Utf8) oldString676)); + } else { + charSequence676 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(676, charSequence676); + } else { + throw new RuntimeException(("Illegal union index for 'F676': "+ unionIndex676)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex677 = (decoder.readIndex()); + if (unionIndex677 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(677, null); + } else { + if (unionIndex677 == 1) { + Utf8 charSequence677; + Object oldString677 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(677); + if (oldString677 instanceof Utf8) { + charSequence677 = (decoder).readString(((Utf8) oldString677)); + } else { + charSequence677 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(677, charSequence677); + } else { + throw new RuntimeException(("Illegal union index for 'F677': "+ unionIndex677)); + } + } + int unionIndex678 = (decoder.readIndex()); + if (unionIndex678 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(678, null); + } else { + if (unionIndex678 == 1) { + Utf8 charSequence678; + Object oldString678 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(678); + if (oldString678 instanceof Utf8) { + charSequence678 = (decoder).readString(((Utf8) oldString678)); + } else { + charSequence678 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(678, charSequence678); + } else { + throw new RuntimeException(("Illegal union index for 'F678': "+ unionIndex678)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex679 = (decoder.readIndex()); + if (unionIndex679 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(679, null); + } else { + if (unionIndex679 == 1) { + Utf8 charSequence679; + Object oldString679 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(679); + if (oldString679 instanceof Utf8) { + charSequence679 = (decoder).readString(((Utf8) oldString679)); + } else { + charSequence679 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(679, charSequence679); + } else { + throw new RuntimeException(("Illegal union index for 'F679': "+ unionIndex679)); + } + } + int unionIndex680 = (decoder.readIndex()); + if (unionIndex680 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(680, null); + } else { + if (unionIndex680 == 1) { + Utf8 charSequence680; + Object oldString680 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(680); + if (oldString680 instanceof Utf8) { + charSequence680 = (decoder).readString(((Utf8) oldString680)); + } else { + charSequence680 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(680, charSequence680); + } else { + throw new RuntimeException(("Illegal union index for 'F680': "+ unionIndex680)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex681 = (decoder.readIndex()); + if (unionIndex681 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(681, null); + } else { + if (unionIndex681 == 1) { + Utf8 charSequence681; + Object oldString681 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(681); + if (oldString681 instanceof Utf8) { + charSequence681 = (decoder).readString(((Utf8) oldString681)); + } else { + charSequence681 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(681, charSequence681); + } else { + throw new RuntimeException(("Illegal union index for 'F681': "+ unionIndex681)); + } + } + int unionIndex682 = (decoder.readIndex()); + if (unionIndex682 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(682, null); + } else { + if (unionIndex682 == 1) { + Utf8 charSequence682; + Object oldString682 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(682); + if (oldString682 instanceof Utf8) { + charSequence682 = (decoder).readString(((Utf8) oldString682)); + } else { + charSequence682 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(682, charSequence682); + } else { + throw new RuntimeException(("Illegal union index for 'F682': "+ unionIndex682)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex683 = (decoder.readIndex()); + if (unionIndex683 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(683, null); + } else { + if (unionIndex683 == 1) { + Utf8 charSequence683; + Object oldString683 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(683); + if (oldString683 instanceof Utf8) { + charSequence683 = (decoder).readString(((Utf8) oldString683)); + } else { + charSequence683 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(683, charSequence683); + } else { + throw new RuntimeException(("Illegal union index for 'F683': "+ unionIndex683)); + } + } + int unionIndex684 = (decoder.readIndex()); + if (unionIndex684 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(684, null); + } else { + if (unionIndex684 == 1) { + Utf8 charSequence684; + Object oldString684 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(684); + if (oldString684 instanceof Utf8) { + charSequence684 = (decoder).readString(((Utf8) oldString684)); + } else { + charSequence684 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(684, charSequence684); + } else { + throw new RuntimeException(("Illegal union index for 'F684': "+ unionIndex684)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex685 = (decoder.readIndex()); + if (unionIndex685 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(685, null); + } else { + if (unionIndex685 == 1) { + Utf8 charSequence685; + Object oldString685 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(685); + if (oldString685 instanceof Utf8) { + charSequence685 = (decoder).readString(((Utf8) oldString685)); + } else { + charSequence685 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(685, charSequence685); + } else { + throw new RuntimeException(("Illegal union index for 'F685': "+ unionIndex685)); + } + } + int unionIndex686 = (decoder.readIndex()); + if (unionIndex686 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(686, null); + } else { + if (unionIndex686 == 1) { + Utf8 charSequence686; + Object oldString686 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(686); + if (oldString686 instanceof Utf8) { + charSequence686 = (decoder).readString(((Utf8) oldString686)); + } else { + charSequence686 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(686, charSequence686); + } else { + throw new RuntimeException(("Illegal union index for 'F686': "+ unionIndex686)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex687 = (decoder.readIndex()); + if (unionIndex687 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(687, null); + } else { + if (unionIndex687 == 1) { + Utf8 charSequence687; + Object oldString687 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(687); + if (oldString687 instanceof Utf8) { + charSequence687 = (decoder).readString(((Utf8) oldString687)); + } else { + charSequence687 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(687, charSequence687); + } else { + throw new RuntimeException(("Illegal union index for 'F687': "+ unionIndex687)); + } + } + int unionIndex688 = (decoder.readIndex()); + if (unionIndex688 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(688, null); + } else { + if (unionIndex688 == 1) { + Utf8 charSequence688; + Object oldString688 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(688); + if (oldString688 instanceof Utf8) { + charSequence688 = (decoder).readString(((Utf8) oldString688)); + } else { + charSequence688 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(688, charSequence688); + } else { + throw new RuntimeException(("Illegal union index for 'F688': "+ unionIndex688)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex689 = (decoder.readIndex()); + if (unionIndex689 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(689, null); + } else { + if (unionIndex689 == 1) { + Utf8 charSequence689; + Object oldString689 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(689); + if (oldString689 instanceof Utf8) { + charSequence689 = (decoder).readString(((Utf8) oldString689)); + } else { + charSequence689 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(689, charSequence689); + } else { + throw new RuntimeException(("Illegal union index for 'F689': "+ unionIndex689)); + } + } + int unionIndex690 = (decoder.readIndex()); + if (unionIndex690 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(690, null); + } else { + if (unionIndex690 == 1) { + Utf8 charSequence690; + Object oldString690 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(690); + if (oldString690 instanceof Utf8) { + charSequence690 = (decoder).readString(((Utf8) oldString690)); + } else { + charSequence690 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(690, charSequence690); + } else { + throw new RuntimeException(("Illegal union index for 'F690': "+ unionIndex690)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex691 = (decoder.readIndex()); + if (unionIndex691 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(691, null); + } else { + if (unionIndex691 == 1) { + Utf8 charSequence691; + Object oldString691 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(691); + if (oldString691 instanceof Utf8) { + charSequence691 = (decoder).readString(((Utf8) oldString691)); + } else { + charSequence691 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(691, charSequence691); + } else { + throw new RuntimeException(("Illegal union index for 'F691': "+ unionIndex691)); + } + } + int unionIndex692 = (decoder.readIndex()); + if (unionIndex692 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(692, null); + } else { + if (unionIndex692 == 1) { + Utf8 charSequence692; + Object oldString692 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(692); + if (oldString692 instanceof Utf8) { + charSequence692 = (decoder).readString(((Utf8) oldString692)); + } else { + charSequence692 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(692, charSequence692); + } else { + throw new RuntimeException(("Illegal union index for 'F692': "+ unionIndex692)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex693 = (decoder.readIndex()); + if (unionIndex693 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(693, null); + } else { + if (unionIndex693 == 1) { + Utf8 charSequence693; + Object oldString693 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(693); + if (oldString693 instanceof Utf8) { + charSequence693 = (decoder).readString(((Utf8) oldString693)); + } else { + charSequence693 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(693, charSequence693); + } else { + throw new RuntimeException(("Illegal union index for 'F693': "+ unionIndex693)); + } + } + int unionIndex694 = (decoder.readIndex()); + if (unionIndex694 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(694, null); + } else { + if (unionIndex694 == 1) { + Utf8 charSequence694; + Object oldString694 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(694); + if (oldString694 instanceof Utf8) { + charSequence694 = (decoder).readString(((Utf8) oldString694)); + } else { + charSequence694 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(694, charSequence694); + } else { + throw new RuntimeException(("Illegal union index for 'F694': "+ unionIndex694)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex695 = (decoder.readIndex()); + if (unionIndex695 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(695, null); + } else { + if (unionIndex695 == 1) { + Utf8 charSequence695; + Object oldString695 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(695); + if (oldString695 instanceof Utf8) { + charSequence695 = (decoder).readString(((Utf8) oldString695)); + } else { + charSequence695 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(695, charSequence695); + } else { + throw new RuntimeException(("Illegal union index for 'F695': "+ unionIndex695)); + } + } + int unionIndex696 = (decoder.readIndex()); + if (unionIndex696 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(696, null); + } else { + if (unionIndex696 == 1) { + Utf8 charSequence696; + Object oldString696 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(696); + if (oldString696 instanceof Utf8) { + charSequence696 = (decoder).readString(((Utf8) oldString696)); + } else { + charSequence696 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(696, charSequence696); + } else { + throw new RuntimeException(("Illegal union index for 'F696': "+ unionIndex696)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex697 = (decoder.readIndex()); + if (unionIndex697 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(697, null); + } else { + if (unionIndex697 == 1) { + Utf8 charSequence697; + Object oldString697 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(697); + if (oldString697 instanceof Utf8) { + charSequence697 = (decoder).readString(((Utf8) oldString697)); + } else { + charSequence697 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(697, charSequence697); + } else { + throw new RuntimeException(("Illegal union index for 'F697': "+ unionIndex697)); + } + } + int unionIndex698 = (decoder.readIndex()); + if (unionIndex698 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(698, null); + } else { + if (unionIndex698 == 1) { + Utf8 charSequence698; + Object oldString698 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(698); + if (oldString698 instanceof Utf8) { + charSequence698 = (decoder).readString(((Utf8) oldString698)); + } else { + charSequence698 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(698, charSequence698); + } else { + throw new RuntimeException(("Illegal union index for 'F698': "+ unionIndex698)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex699 = (decoder.readIndex()); + if (unionIndex699 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(699, null); + } else { + if (unionIndex699 == 1) { + Utf8 charSequence699; + Object oldString699 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(699); + if (oldString699 instanceof Utf8) { + charSequence699 = (decoder).readString(((Utf8) oldString699)); + } else { + charSequence699 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(699, charSequence699); + } else { + throw new RuntimeException(("Illegal union index for 'F699': "+ unionIndex699)); + } + } + int unionIndex700 = (decoder.readIndex()); + if (unionIndex700 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(700, null); + } else { + if (unionIndex700 == 1) { + Utf8 charSequence700; + Object oldString700 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(700); + if (oldString700 instanceof Utf8) { + charSequence700 = (decoder).readString(((Utf8) oldString700)); + } else { + charSequence700 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(700, charSequence700); + } else { + throw new RuntimeException(("Illegal union index for 'F700': "+ unionIndex700)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex701 = (decoder.readIndex()); + if (unionIndex701 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(701, null); + } else { + if (unionIndex701 == 1) { + Utf8 charSequence701; + Object oldString701 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(701); + if (oldString701 instanceof Utf8) { + charSequence701 = (decoder).readString(((Utf8) oldString701)); + } else { + charSequence701 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(701, charSequence701); + } else { + throw new RuntimeException(("Illegal union index for 'F701': "+ unionIndex701)); + } + } + int unionIndex702 = (decoder.readIndex()); + if (unionIndex702 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(702, null); + } else { + if (unionIndex702 == 1) { + Utf8 charSequence702; + Object oldString702 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(702); + if (oldString702 instanceof Utf8) { + charSequence702 = (decoder).readString(((Utf8) oldString702)); + } else { + charSequence702 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(702, charSequence702); + } else { + throw new RuntimeException(("Illegal union index for 'F702': "+ unionIndex702)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex703 = (decoder.readIndex()); + if (unionIndex703 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(703, null); + } else { + if (unionIndex703 == 1) { + Utf8 charSequence703; + Object oldString703 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(703); + if (oldString703 instanceof Utf8) { + charSequence703 = (decoder).readString(((Utf8) oldString703)); + } else { + charSequence703 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(703, charSequence703); + } else { + throw new RuntimeException(("Illegal union index for 'F703': "+ unionIndex703)); + } + } + int unionIndex704 = (decoder.readIndex()); + if (unionIndex704 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(704, null); + } else { + if (unionIndex704 == 1) { + Utf8 charSequence704; + Object oldString704 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(704); + if (oldString704 instanceof Utf8) { + charSequence704 = (decoder).readString(((Utf8) oldString704)); + } else { + charSequence704 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(704, charSequence704); + } else { + throw new RuntimeException(("Illegal union index for 'F704': "+ unionIndex704)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex705 = (decoder.readIndex()); + if (unionIndex705 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(705, null); + } else { + if (unionIndex705 == 1) { + Utf8 charSequence705; + Object oldString705 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(705); + if (oldString705 instanceof Utf8) { + charSequence705 = (decoder).readString(((Utf8) oldString705)); + } else { + charSequence705 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(705, charSequence705); + } else { + throw new RuntimeException(("Illegal union index for 'F705': "+ unionIndex705)); + } + } + int unionIndex706 = (decoder.readIndex()); + if (unionIndex706 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(706, null); + } else { + if (unionIndex706 == 1) { + Utf8 charSequence706; + Object oldString706 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(706); + if (oldString706 instanceof Utf8) { + charSequence706 = (decoder).readString(((Utf8) oldString706)); + } else { + charSequence706 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(706, charSequence706); + } else { + throw new RuntimeException(("Illegal union index for 'F706': "+ unionIndex706)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex707 = (decoder.readIndex()); + if (unionIndex707 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(707, null); + } else { + if (unionIndex707 == 1) { + Utf8 charSequence707; + Object oldString707 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(707); + if (oldString707 instanceof Utf8) { + charSequence707 = (decoder).readString(((Utf8) oldString707)); + } else { + charSequence707 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(707, charSequence707); + } else { + throw new RuntimeException(("Illegal union index for 'F707': "+ unionIndex707)); + } + } + int unionIndex708 = (decoder.readIndex()); + if (unionIndex708 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(708, null); + } else { + if (unionIndex708 == 1) { + Utf8 charSequence708; + Object oldString708 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(708); + if (oldString708 instanceof Utf8) { + charSequence708 = (decoder).readString(((Utf8) oldString708)); + } else { + charSequence708 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(708, charSequence708); + } else { + throw new RuntimeException(("Illegal union index for 'F708': "+ unionIndex708)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex709 = (decoder.readIndex()); + if (unionIndex709 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(709, null); + } else { + if (unionIndex709 == 1) { + Utf8 charSequence709; + Object oldString709 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(709); + if (oldString709 instanceof Utf8) { + charSequence709 = (decoder).readString(((Utf8) oldString709)); + } else { + charSequence709 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(709, charSequence709); + } else { + throw new RuntimeException(("Illegal union index for 'F709': "+ unionIndex709)); + } + } + int unionIndex710 = (decoder.readIndex()); + if (unionIndex710 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(710, null); + } else { + if (unionIndex710 == 1) { + Utf8 charSequence710; + Object oldString710 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(710); + if (oldString710 instanceof Utf8) { + charSequence710 = (decoder).readString(((Utf8) oldString710)); + } else { + charSequence710 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(710, charSequence710); + } else { + throw new RuntimeException(("Illegal union index for 'F710': "+ unionIndex710)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex711 = (decoder.readIndex()); + if (unionIndex711 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(711, null); + } else { + if (unionIndex711 == 1) { + Utf8 charSequence711; + Object oldString711 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(711); + if (oldString711 instanceof Utf8) { + charSequence711 = (decoder).readString(((Utf8) oldString711)); + } else { + charSequence711 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(711, charSequence711); + } else { + throw new RuntimeException(("Illegal union index for 'F711': "+ unionIndex711)); + } + } + int unionIndex712 = (decoder.readIndex()); + if (unionIndex712 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(712, null); + } else { + if (unionIndex712 == 1) { + Utf8 charSequence712; + Object oldString712 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(712); + if (oldString712 instanceof Utf8) { + charSequence712 = (decoder).readString(((Utf8) oldString712)); + } else { + charSequence712 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(712, charSequence712); + } else { + throw new RuntimeException(("Illegal union index for 'F712': "+ unionIndex712)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex713 = (decoder.readIndex()); + if (unionIndex713 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(713, null); + } else { + if (unionIndex713 == 1) { + Utf8 charSequence713; + Object oldString713 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(713); + if (oldString713 instanceof Utf8) { + charSequence713 = (decoder).readString(((Utf8) oldString713)); + } else { + charSequence713 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(713, charSequence713); + } else { + throw new RuntimeException(("Illegal union index for 'F713': "+ unionIndex713)); + } + } + int unionIndex714 = (decoder.readIndex()); + if (unionIndex714 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(714, null); + } else { + if (unionIndex714 == 1) { + Utf8 charSequence714; + Object oldString714 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(714); + if (oldString714 instanceof Utf8) { + charSequence714 = (decoder).readString(((Utf8) oldString714)); + } else { + charSequence714 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(714, charSequence714); + } else { + throw new RuntimeException(("Illegal union index for 'F714': "+ unionIndex714)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex715 = (decoder.readIndex()); + if (unionIndex715 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(715, null); + } else { + if (unionIndex715 == 1) { + Utf8 charSequence715; + Object oldString715 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(715); + if (oldString715 instanceof Utf8) { + charSequence715 = (decoder).readString(((Utf8) oldString715)); + } else { + charSequence715 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(715, charSequence715); + } else { + throw new RuntimeException(("Illegal union index for 'F715': "+ unionIndex715)); + } + } + int unionIndex716 = (decoder.readIndex()); + if (unionIndex716 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(716, null); + } else { + if (unionIndex716 == 1) { + Utf8 charSequence716; + Object oldString716 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(716); + if (oldString716 instanceof Utf8) { + charSequence716 = (decoder).readString(((Utf8) oldString716)); + } else { + charSequence716 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(716, charSequence716); + } else { + throw new RuntimeException(("Illegal union index for 'F716': "+ unionIndex716)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex717 = (decoder.readIndex()); + if (unionIndex717 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(717, null); + } else { + if (unionIndex717 == 1) { + Utf8 charSequence717; + Object oldString717 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(717); + if (oldString717 instanceof Utf8) { + charSequence717 = (decoder).readString(((Utf8) oldString717)); + } else { + charSequence717 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(717, charSequence717); + } else { + throw new RuntimeException(("Illegal union index for 'F717': "+ unionIndex717)); + } + } + int unionIndex718 = (decoder.readIndex()); + if (unionIndex718 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(718, null); + } else { + if (unionIndex718 == 1) { + Utf8 charSequence718; + Object oldString718 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(718); + if (oldString718 instanceof Utf8) { + charSequence718 = (decoder).readString(((Utf8) oldString718)); + } else { + charSequence718 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(718, charSequence718); + } else { + throw new RuntimeException(("Illegal union index for 'F718': "+ unionIndex718)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex719 = (decoder.readIndex()); + if (unionIndex719 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(719, null); + } else { + if (unionIndex719 == 1) { + Utf8 charSequence719; + Object oldString719 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(719); + if (oldString719 instanceof Utf8) { + charSequence719 = (decoder).readString(((Utf8) oldString719)); + } else { + charSequence719 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(719, charSequence719); + } else { + throw new RuntimeException(("Illegal union index for 'F719': "+ unionIndex719)); + } + } + int unionIndex720 = (decoder.readIndex()); + if (unionIndex720 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(720, null); + } else { + if (unionIndex720 == 1) { + Utf8 charSequence720; + Object oldString720 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(720); + if (oldString720 instanceof Utf8) { + charSequence720 = (decoder).readString(((Utf8) oldString720)); + } else { + charSequence720 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(720, charSequence720); + } else { + throw new RuntimeException(("Illegal union index for 'F720': "+ unionIndex720)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex721 = (decoder.readIndex()); + if (unionIndex721 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(721, null); + } else { + if (unionIndex721 == 1) { + Utf8 charSequence721; + Object oldString721 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(721); + if (oldString721 instanceof Utf8) { + charSequence721 = (decoder).readString(((Utf8) oldString721)); + } else { + charSequence721 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(721, charSequence721); + } else { + throw new RuntimeException(("Illegal union index for 'F721': "+ unionIndex721)); + } + } + int unionIndex722 = (decoder.readIndex()); + if (unionIndex722 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(722, null); + } else { + if (unionIndex722 == 1) { + Utf8 charSequence722; + Object oldString722 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(722); + if (oldString722 instanceof Utf8) { + charSequence722 = (decoder).readString(((Utf8) oldString722)); + } else { + charSequence722 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(722, charSequence722); + } else { + throw new RuntimeException(("Illegal union index for 'F722': "+ unionIndex722)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex723 = (decoder.readIndex()); + if (unionIndex723 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(723, null); + } else { + if (unionIndex723 == 1) { + Utf8 charSequence723; + Object oldString723 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(723); + if (oldString723 instanceof Utf8) { + charSequence723 = (decoder).readString(((Utf8) oldString723)); + } else { + charSequence723 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(723, charSequence723); + } else { + throw new RuntimeException(("Illegal union index for 'F723': "+ unionIndex723)); + } + } + int unionIndex724 = (decoder.readIndex()); + if (unionIndex724 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(724, null); + } else { + if (unionIndex724 == 1) { + Utf8 charSequence724; + Object oldString724 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(724); + if (oldString724 instanceof Utf8) { + charSequence724 = (decoder).readString(((Utf8) oldString724)); + } else { + charSequence724 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(724, charSequence724); + } else { + throw new RuntimeException(("Illegal union index for 'F724': "+ unionIndex724)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex725 = (decoder.readIndex()); + if (unionIndex725 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(725, null); + } else { + if (unionIndex725 == 1) { + Utf8 charSequence725; + Object oldString725 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(725); + if (oldString725 instanceof Utf8) { + charSequence725 = (decoder).readString(((Utf8) oldString725)); + } else { + charSequence725 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(725, charSequence725); + } else { + throw new RuntimeException(("Illegal union index for 'F725': "+ unionIndex725)); + } + } + int unionIndex726 = (decoder.readIndex()); + if (unionIndex726 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(726, null); + } else { + if (unionIndex726 == 1) { + Utf8 charSequence726; + Object oldString726 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(726); + if (oldString726 instanceof Utf8) { + charSequence726 = (decoder).readString(((Utf8) oldString726)); + } else { + charSequence726 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(726, charSequence726); + } else { + throw new RuntimeException(("Illegal union index for 'F726': "+ unionIndex726)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex727 = (decoder.readIndex()); + if (unionIndex727 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(727, null); + } else { + if (unionIndex727 == 1) { + Utf8 charSequence727; + Object oldString727 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(727); + if (oldString727 instanceof Utf8) { + charSequence727 = (decoder).readString(((Utf8) oldString727)); + } else { + charSequence727 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(727, charSequence727); + } else { + throw new RuntimeException(("Illegal union index for 'F727': "+ unionIndex727)); + } + } + int unionIndex728 = (decoder.readIndex()); + if (unionIndex728 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(728, null); + } else { + if (unionIndex728 == 1) { + Utf8 charSequence728; + Object oldString728 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(728); + if (oldString728 instanceof Utf8) { + charSequence728 = (decoder).readString(((Utf8) oldString728)); + } else { + charSequence728 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(728, charSequence728); + } else { + throw new RuntimeException(("Illegal union index for 'F728': "+ unionIndex728)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex729 = (decoder.readIndex()); + if (unionIndex729 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(729, null); + } else { + if (unionIndex729 == 1) { + Utf8 charSequence729; + Object oldString729 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(729); + if (oldString729 instanceof Utf8) { + charSequence729 = (decoder).readString(((Utf8) oldString729)); + } else { + charSequence729 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(729, charSequence729); + } else { + throw new RuntimeException(("Illegal union index for 'F729': "+ unionIndex729)); + } + } + int unionIndex730 = (decoder.readIndex()); + if (unionIndex730 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(730, null); + } else { + if (unionIndex730 == 1) { + Utf8 charSequence730; + Object oldString730 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(730); + if (oldString730 instanceof Utf8) { + charSequence730 = (decoder).readString(((Utf8) oldString730)); + } else { + charSequence730 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(730, charSequence730); + } else { + throw new RuntimeException(("Illegal union index for 'F730': "+ unionIndex730)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex731 = (decoder.readIndex()); + if (unionIndex731 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(731, null); + } else { + if (unionIndex731 == 1) { + Utf8 charSequence731; + Object oldString731 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(731); + if (oldString731 instanceof Utf8) { + charSequence731 = (decoder).readString(((Utf8) oldString731)); + } else { + charSequence731 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(731, charSequence731); + } else { + throw new RuntimeException(("Illegal union index for 'F731': "+ unionIndex731)); + } + } + int unionIndex732 = (decoder.readIndex()); + if (unionIndex732 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(732, null); + } else { + if (unionIndex732 == 1) { + Utf8 charSequence732; + Object oldString732 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(732); + if (oldString732 instanceof Utf8) { + charSequence732 = (decoder).readString(((Utf8) oldString732)); + } else { + charSequence732 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(732, charSequence732); + } else { + throw new RuntimeException(("Illegal union index for 'F732': "+ unionIndex732)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex733 = (decoder.readIndex()); + if (unionIndex733 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(733, null); + } else { + if (unionIndex733 == 1) { + Utf8 charSequence733; + Object oldString733 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(733); + if (oldString733 instanceof Utf8) { + charSequence733 = (decoder).readString(((Utf8) oldString733)); + } else { + charSequence733 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(733, charSequence733); + } else { + throw new RuntimeException(("Illegal union index for 'F733': "+ unionIndex733)); + } + } + int unionIndex734 = (decoder.readIndex()); + if (unionIndex734 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(734, null); + } else { + if (unionIndex734 == 1) { + Utf8 charSequence734; + Object oldString734 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(734); + if (oldString734 instanceof Utf8) { + charSequence734 = (decoder).readString(((Utf8) oldString734)); + } else { + charSequence734 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(734, charSequence734); + } else { + throw new RuntimeException(("Illegal union index for 'F734': "+ unionIndex734)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex735 = (decoder.readIndex()); + if (unionIndex735 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(735, null); + } else { + if (unionIndex735 == 1) { + Utf8 charSequence735; + Object oldString735 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(735); + if (oldString735 instanceof Utf8) { + charSequence735 = (decoder).readString(((Utf8) oldString735)); + } else { + charSequence735 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(735, charSequence735); + } else { + throw new RuntimeException(("Illegal union index for 'F735': "+ unionIndex735)); + } + } + int unionIndex736 = (decoder.readIndex()); + if (unionIndex736 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(736, null); + } else { + if (unionIndex736 == 1) { + Utf8 charSequence736; + Object oldString736 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(736); + if (oldString736 instanceof Utf8) { + charSequence736 = (decoder).readString(((Utf8) oldString736)); + } else { + charSequence736 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(736, charSequence736); + } else { + throw new RuntimeException(("Illegal union index for 'F736': "+ unionIndex736)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex737 = (decoder.readIndex()); + if (unionIndex737 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(737, null); + } else { + if (unionIndex737 == 1) { + Utf8 charSequence737; + Object oldString737 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(737); + if (oldString737 instanceof Utf8) { + charSequence737 = (decoder).readString(((Utf8) oldString737)); + } else { + charSequence737 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(737, charSequence737); + } else { + throw new RuntimeException(("Illegal union index for 'F737': "+ unionIndex737)); + } + } + int unionIndex738 = (decoder.readIndex()); + if (unionIndex738 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(738, null); + } else { + if (unionIndex738 == 1) { + Utf8 charSequence738; + Object oldString738 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(738); + if (oldString738 instanceof Utf8) { + charSequence738 = (decoder).readString(((Utf8) oldString738)); + } else { + charSequence738 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(738, charSequence738); + } else { + throw new RuntimeException(("Illegal union index for 'F738': "+ unionIndex738)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex739 = (decoder.readIndex()); + if (unionIndex739 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(739, null); + } else { + if (unionIndex739 == 1) { + Utf8 charSequence739; + Object oldString739 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(739); + if (oldString739 instanceof Utf8) { + charSequence739 = (decoder).readString(((Utf8) oldString739)); + } else { + charSequence739 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(739, charSequence739); + } else { + throw new RuntimeException(("Illegal union index for 'F739': "+ unionIndex739)); + } + } + int unionIndex740 = (decoder.readIndex()); + if (unionIndex740 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(740, null); + } else { + if (unionIndex740 == 1) { + Utf8 charSequence740; + Object oldString740 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(740); + if (oldString740 instanceof Utf8) { + charSequence740 = (decoder).readString(((Utf8) oldString740)); + } else { + charSequence740 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(740, charSequence740); + } else { + throw new RuntimeException(("Illegal union index for 'F740': "+ unionIndex740)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex741 = (decoder.readIndex()); + if (unionIndex741 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(741, null); + } else { + if (unionIndex741 == 1) { + Utf8 charSequence741; + Object oldString741 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(741); + if (oldString741 instanceof Utf8) { + charSequence741 = (decoder).readString(((Utf8) oldString741)); + } else { + charSequence741 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(741, charSequence741); + } else { + throw new RuntimeException(("Illegal union index for 'F741': "+ unionIndex741)); + } + } + int unionIndex742 = (decoder.readIndex()); + if (unionIndex742 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(742, null); + } else { + if (unionIndex742 == 1) { + Utf8 charSequence742; + Object oldString742 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(742); + if (oldString742 instanceof Utf8) { + charSequence742 = (decoder).readString(((Utf8) oldString742)); + } else { + charSequence742 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(742, charSequence742); + } else { + throw new RuntimeException(("Illegal union index for 'F742': "+ unionIndex742)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex743 = (decoder.readIndex()); + if (unionIndex743 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(743, null); + } else { + if (unionIndex743 == 1) { + Utf8 charSequence743; + Object oldString743 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(743); + if (oldString743 instanceof Utf8) { + charSequence743 = (decoder).readString(((Utf8) oldString743)); + } else { + charSequence743 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(743, charSequence743); + } else { + throw new RuntimeException(("Illegal union index for 'F743': "+ unionIndex743)); + } + } + int unionIndex744 = (decoder.readIndex()); + if (unionIndex744 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(744, null); + } else { + if (unionIndex744 == 1) { + Utf8 charSequence744; + Object oldString744 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(744); + if (oldString744 instanceof Utf8) { + charSequence744 = (decoder).readString(((Utf8) oldString744)); + } else { + charSequence744 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(744, charSequence744); + } else { + throw new RuntimeException(("Illegal union index for 'F744': "+ unionIndex744)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex745 = (decoder.readIndex()); + if (unionIndex745 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(745, null); + } else { + if (unionIndex745 == 1) { + Utf8 charSequence745; + Object oldString745 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(745); + if (oldString745 instanceof Utf8) { + charSequence745 = (decoder).readString(((Utf8) oldString745)); + } else { + charSequence745 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(745, charSequence745); + } else { + throw new RuntimeException(("Illegal union index for 'F745': "+ unionIndex745)); + } + } + int unionIndex746 = (decoder.readIndex()); + if (unionIndex746 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(746, null); + } else { + if (unionIndex746 == 1) { + Utf8 charSequence746; + Object oldString746 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(746); + if (oldString746 instanceof Utf8) { + charSequence746 = (decoder).readString(((Utf8) oldString746)); + } else { + charSequence746 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(746, charSequence746); + } else { + throw new RuntimeException(("Illegal union index for 'F746': "+ unionIndex746)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex747 = (decoder.readIndex()); + if (unionIndex747 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(747, null); + } else { + if (unionIndex747 == 1) { + Utf8 charSequence747; + Object oldString747 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(747); + if (oldString747 instanceof Utf8) { + charSequence747 = (decoder).readString(((Utf8) oldString747)); + } else { + charSequence747 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(747, charSequence747); + } else { + throw new RuntimeException(("Illegal union index for 'F747': "+ unionIndex747)); + } + } + int unionIndex748 = (decoder.readIndex()); + if (unionIndex748 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(748, null); + } else { + if (unionIndex748 == 1) { + Utf8 charSequence748; + Object oldString748 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(748); + if (oldString748 instanceof Utf8) { + charSequence748 = (decoder).readString(((Utf8) oldString748)); + } else { + charSequence748 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(748, charSequence748); + } else { + throw new RuntimeException(("Illegal union index for 'F748': "+ unionIndex748)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex749 = (decoder.readIndex()); + if (unionIndex749 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(749, null); + } else { + if (unionIndex749 == 1) { + Utf8 charSequence749; + Object oldString749 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(749); + if (oldString749 instanceof Utf8) { + charSequence749 = (decoder).readString(((Utf8) oldString749)); + } else { + charSequence749 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(749, charSequence749); + } else { + throw new RuntimeException(("Illegal union index for 'F749': "+ unionIndex749)); + } + } + int unionIndex750 = (decoder.readIndex()); + if (unionIndex750 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(750, null); + } else { + if (unionIndex750 == 1) { + Utf8 charSequence750; + Object oldString750 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(750); + if (oldString750 instanceof Utf8) { + charSequence750 = (decoder).readString(((Utf8) oldString750)); + } else { + charSequence750 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(750, charSequence750); + } else { + throw new RuntimeException(("Illegal union index for 'F750': "+ unionIndex750)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex751 = (decoder.readIndex()); + if (unionIndex751 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(751, null); + } else { + if (unionIndex751 == 1) { + Utf8 charSequence751; + Object oldString751 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(751); + if (oldString751 instanceof Utf8) { + charSequence751 = (decoder).readString(((Utf8) oldString751)); + } else { + charSequence751 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(751, charSequence751); + } else { + throw new RuntimeException(("Illegal union index for 'F751': "+ unionIndex751)); + } + } + int unionIndex752 = (decoder.readIndex()); + if (unionIndex752 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(752, null); + } else { + if (unionIndex752 == 1) { + Utf8 charSequence752; + Object oldString752 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(752); + if (oldString752 instanceof Utf8) { + charSequence752 = (decoder).readString(((Utf8) oldString752)); + } else { + charSequence752 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(752, charSequence752); + } else { + throw new RuntimeException(("Illegal union index for 'F752': "+ unionIndex752)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex753 = (decoder.readIndex()); + if (unionIndex753 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(753, null); + } else { + if (unionIndex753 == 1) { + Utf8 charSequence753; + Object oldString753 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(753); + if (oldString753 instanceof Utf8) { + charSequence753 = (decoder).readString(((Utf8) oldString753)); + } else { + charSequence753 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(753, charSequence753); + } else { + throw new RuntimeException(("Illegal union index for 'F753': "+ unionIndex753)); + } + } + int unionIndex754 = (decoder.readIndex()); + if (unionIndex754 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(754, null); + } else { + if (unionIndex754 == 1) { + Utf8 charSequence754; + Object oldString754 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(754); + if (oldString754 instanceof Utf8) { + charSequence754 = (decoder).readString(((Utf8) oldString754)); + } else { + charSequence754 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(754, charSequence754); + } else { + throw new RuntimeException(("Illegal union index for 'F754': "+ unionIndex754)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex755 = (decoder.readIndex()); + if (unionIndex755 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(755, null); + } else { + if (unionIndex755 == 1) { + Utf8 charSequence755; + Object oldString755 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(755); + if (oldString755 instanceof Utf8) { + charSequence755 = (decoder).readString(((Utf8) oldString755)); + } else { + charSequence755 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(755, charSequence755); + } else { + throw new RuntimeException(("Illegal union index for 'F755': "+ unionIndex755)); + } + } + int unionIndex756 = (decoder.readIndex()); + if (unionIndex756 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(756, null); + } else { + if (unionIndex756 == 1) { + Utf8 charSequence756; + Object oldString756 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(756); + if (oldString756 instanceof Utf8) { + charSequence756 = (decoder).readString(((Utf8) oldString756)); + } else { + charSequence756 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(756, charSequence756); + } else { + throw new RuntimeException(("Illegal union index for 'F756': "+ unionIndex756)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex757 = (decoder.readIndex()); + if (unionIndex757 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(757, null); + } else { + if (unionIndex757 == 1) { + Utf8 charSequence757; + Object oldString757 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(757); + if (oldString757 instanceof Utf8) { + charSequence757 = (decoder).readString(((Utf8) oldString757)); + } else { + charSequence757 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(757, charSequence757); + } else { + throw new RuntimeException(("Illegal union index for 'F757': "+ unionIndex757)); + } + } + int unionIndex758 = (decoder.readIndex()); + if (unionIndex758 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(758, null); + } else { + if (unionIndex758 == 1) { + Utf8 charSequence758; + Object oldString758 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(758); + if (oldString758 instanceof Utf8) { + charSequence758 = (decoder).readString(((Utf8) oldString758)); + } else { + charSequence758 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(758, charSequence758); + } else { + throw new RuntimeException(("Illegal union index for 'F758': "+ unionIndex758)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex759 = (decoder.readIndex()); + if (unionIndex759 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(759, null); + } else { + if (unionIndex759 == 1) { + Utf8 charSequence759; + Object oldString759 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(759); + if (oldString759 instanceof Utf8) { + charSequence759 = (decoder).readString(((Utf8) oldString759)); + } else { + charSequence759 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(759, charSequence759); + } else { + throw new RuntimeException(("Illegal union index for 'F759': "+ unionIndex759)); + } + } + int unionIndex760 = (decoder.readIndex()); + if (unionIndex760 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(760, null); + } else { + if (unionIndex760 == 1) { + Utf8 charSequence760; + Object oldString760 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(760); + if (oldString760 instanceof Utf8) { + charSequence760 = (decoder).readString(((Utf8) oldString760)); + } else { + charSequence760 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(760, charSequence760); + } else { + throw new RuntimeException(("Illegal union index for 'F760': "+ unionIndex760)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex761 = (decoder.readIndex()); + if (unionIndex761 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(761, null); + } else { + if (unionIndex761 == 1) { + Utf8 charSequence761; + Object oldString761 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(761); + if (oldString761 instanceof Utf8) { + charSequence761 = (decoder).readString(((Utf8) oldString761)); + } else { + charSequence761 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(761, charSequence761); + } else { + throw new RuntimeException(("Illegal union index for 'F761': "+ unionIndex761)); + } + } + int unionIndex762 = (decoder.readIndex()); + if (unionIndex762 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(762, null); + } else { + if (unionIndex762 == 1) { + Utf8 charSequence762; + Object oldString762 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(762); + if (oldString762 instanceof Utf8) { + charSequence762 = (decoder).readString(((Utf8) oldString762)); + } else { + charSequence762 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(762, charSequence762); + } else { + throw new RuntimeException(("Illegal union index for 'F762': "+ unionIndex762)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex763 = (decoder.readIndex()); + if (unionIndex763 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(763, null); + } else { + if (unionIndex763 == 1) { + Utf8 charSequence763; + Object oldString763 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(763); + if (oldString763 instanceof Utf8) { + charSequence763 = (decoder).readString(((Utf8) oldString763)); + } else { + charSequence763 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(763, charSequence763); + } else { + throw new RuntimeException(("Illegal union index for 'F763': "+ unionIndex763)); + } + } + int unionIndex764 = (decoder.readIndex()); + if (unionIndex764 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(764, null); + } else { + if (unionIndex764 == 1) { + Utf8 charSequence764; + Object oldString764 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(764); + if (oldString764 instanceof Utf8) { + charSequence764 = (decoder).readString(((Utf8) oldString764)); + } else { + charSequence764 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(764, charSequence764); + } else { + throw new RuntimeException(("Illegal union index for 'F764': "+ unionIndex764)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex765 = (decoder.readIndex()); + if (unionIndex765 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(765, null); + } else { + if (unionIndex765 == 1) { + Utf8 charSequence765; + Object oldString765 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(765); + if (oldString765 instanceof Utf8) { + charSequence765 = (decoder).readString(((Utf8) oldString765)); + } else { + charSequence765 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(765, charSequence765); + } else { + throw new RuntimeException(("Illegal union index for 'F765': "+ unionIndex765)); + } + } + int unionIndex766 = (decoder.readIndex()); + if (unionIndex766 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(766, null); + } else { + if (unionIndex766 == 1) { + Utf8 charSequence766; + Object oldString766 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(766); + if (oldString766 instanceof Utf8) { + charSequence766 = (decoder).readString(((Utf8) oldString766)); + } else { + charSequence766 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(766, charSequence766); + } else { + throw new RuntimeException(("Illegal union index for 'F766': "+ unionIndex766)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex767 = (decoder.readIndex()); + if (unionIndex767 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(767, null); + } else { + if (unionIndex767 == 1) { + Utf8 charSequence767; + Object oldString767 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(767); + if (oldString767 instanceof Utf8) { + charSequence767 = (decoder).readString(((Utf8) oldString767)); + } else { + charSequence767 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(767, charSequence767); + } else { + throw new RuntimeException(("Illegal union index for 'F767': "+ unionIndex767)); + } + } + int unionIndex768 = (decoder.readIndex()); + if (unionIndex768 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(768, null); + } else { + if (unionIndex768 == 1) { + Utf8 charSequence768; + Object oldString768 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(768); + if (oldString768 instanceof Utf8) { + charSequence768 = (decoder).readString(((Utf8) oldString768)); + } else { + charSequence768 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(768, charSequence768); + } else { + throw new RuntimeException(("Illegal union index for 'F768': "+ unionIndex768)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex769 = (decoder.readIndex()); + if (unionIndex769 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(769, null); + } else { + if (unionIndex769 == 1) { + Utf8 charSequence769; + Object oldString769 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(769); + if (oldString769 instanceof Utf8) { + charSequence769 = (decoder).readString(((Utf8) oldString769)); + } else { + charSequence769 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(769, charSequence769); + } else { + throw new RuntimeException(("Illegal union index for 'F769': "+ unionIndex769)); + } + } + int unionIndex770 = (decoder.readIndex()); + if (unionIndex770 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(770, null); + } else { + if (unionIndex770 == 1) { + Utf8 charSequence770; + Object oldString770 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(770); + if (oldString770 instanceof Utf8) { + charSequence770 = (decoder).readString(((Utf8) oldString770)); + } else { + charSequence770 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(770, charSequence770); + } else { + throw new RuntimeException(("Illegal union index for 'F770': "+ unionIndex770)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex771 = (decoder.readIndex()); + if (unionIndex771 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(771, null); + } else { + if (unionIndex771 == 1) { + Utf8 charSequence771; + Object oldString771 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(771); + if (oldString771 instanceof Utf8) { + charSequence771 = (decoder).readString(((Utf8) oldString771)); + } else { + charSequence771 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(771, charSequence771); + } else { + throw new RuntimeException(("Illegal union index for 'F771': "+ unionIndex771)); + } + } + int unionIndex772 = (decoder.readIndex()); + if (unionIndex772 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(772, null); + } else { + if (unionIndex772 == 1) { + Utf8 charSequence772; + Object oldString772 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(772); + if (oldString772 instanceof Utf8) { + charSequence772 = (decoder).readString(((Utf8) oldString772)); + } else { + charSequence772 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(772, charSequence772); + } else { + throw new RuntimeException(("Illegal union index for 'F772': "+ unionIndex772)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex773 = (decoder.readIndex()); + if (unionIndex773 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(773, null); + } else { + if (unionIndex773 == 1) { + Utf8 charSequence773; + Object oldString773 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(773); + if (oldString773 instanceof Utf8) { + charSequence773 = (decoder).readString(((Utf8) oldString773)); + } else { + charSequence773 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(773, charSequence773); + } else { + throw new RuntimeException(("Illegal union index for 'F773': "+ unionIndex773)); + } + } + int unionIndex774 = (decoder.readIndex()); + if (unionIndex774 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(774, null); + } else { + if (unionIndex774 == 1) { + Utf8 charSequence774; + Object oldString774 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(774); + if (oldString774 instanceof Utf8) { + charSequence774 = (decoder).readString(((Utf8) oldString774)); + } else { + charSequence774 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(774, charSequence774); + } else { + throw new RuntimeException(("Illegal union index for 'F774': "+ unionIndex774)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex775 = (decoder.readIndex()); + if (unionIndex775 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(775, null); + } else { + if (unionIndex775 == 1) { + Utf8 charSequence775; + Object oldString775 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(775); + if (oldString775 instanceof Utf8) { + charSequence775 = (decoder).readString(((Utf8) oldString775)); + } else { + charSequence775 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(775, charSequence775); + } else { + throw new RuntimeException(("Illegal union index for 'F775': "+ unionIndex775)); + } + } + int unionIndex776 = (decoder.readIndex()); + if (unionIndex776 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(776, null); + } else { + if (unionIndex776 == 1) { + Utf8 charSequence776; + Object oldString776 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(776); + if (oldString776 instanceof Utf8) { + charSequence776 = (decoder).readString(((Utf8) oldString776)); + } else { + charSequence776 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(776, charSequence776); + } else { + throw new RuntimeException(("Illegal union index for 'F776': "+ unionIndex776)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex777 = (decoder.readIndex()); + if (unionIndex777 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(777, null); + } else { + if (unionIndex777 == 1) { + Utf8 charSequence777; + Object oldString777 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(777); + if (oldString777 instanceof Utf8) { + charSequence777 = (decoder).readString(((Utf8) oldString777)); + } else { + charSequence777 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(777, charSequence777); + } else { + throw new RuntimeException(("Illegal union index for 'F777': "+ unionIndex777)); + } + } + int unionIndex778 = (decoder.readIndex()); + if (unionIndex778 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(778, null); + } else { + if (unionIndex778 == 1) { + Utf8 charSequence778; + Object oldString778 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(778); + if (oldString778 instanceof Utf8) { + charSequence778 = (decoder).readString(((Utf8) oldString778)); + } else { + charSequence778 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(778, charSequence778); + } else { + throw new RuntimeException(("Illegal union index for 'F778': "+ unionIndex778)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex779 = (decoder.readIndex()); + if (unionIndex779 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(779, null); + } else { + if (unionIndex779 == 1) { + Utf8 charSequence779; + Object oldString779 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(779); + if (oldString779 instanceof Utf8) { + charSequence779 = (decoder).readString(((Utf8) oldString779)); + } else { + charSequence779 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(779, charSequence779); + } else { + throw new RuntimeException(("Illegal union index for 'F779': "+ unionIndex779)); + } + } + int unionIndex780 = (decoder.readIndex()); + if (unionIndex780 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(780, null); + } else { + if (unionIndex780 == 1) { + Utf8 charSequence780; + Object oldString780 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(780); + if (oldString780 instanceof Utf8) { + charSequence780 = (decoder).readString(((Utf8) oldString780)); + } else { + charSequence780 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(780, charSequence780); + } else { + throw new RuntimeException(("Illegal union index for 'F780': "+ unionIndex780)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex781 = (decoder.readIndex()); + if (unionIndex781 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(781, null); + } else { + if (unionIndex781 == 1) { + Utf8 charSequence781; + Object oldString781 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(781); + if (oldString781 instanceof Utf8) { + charSequence781 = (decoder).readString(((Utf8) oldString781)); + } else { + charSequence781 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(781, charSequence781); + } else { + throw new RuntimeException(("Illegal union index for 'F781': "+ unionIndex781)); + } + } + int unionIndex782 = (decoder.readIndex()); + if (unionIndex782 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(782, null); + } else { + if (unionIndex782 == 1) { + Utf8 charSequence782; + Object oldString782 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(782); + if (oldString782 instanceof Utf8) { + charSequence782 = (decoder).readString(((Utf8) oldString782)); + } else { + charSequence782 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(782, charSequence782); + } else { + throw new RuntimeException(("Illegal union index for 'F782': "+ unionIndex782)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex783 = (decoder.readIndex()); + if (unionIndex783 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(783, null); + } else { + if (unionIndex783 == 1) { + Utf8 charSequence783; + Object oldString783 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(783); + if (oldString783 instanceof Utf8) { + charSequence783 = (decoder).readString(((Utf8) oldString783)); + } else { + charSequence783 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(783, charSequence783); + } else { + throw new RuntimeException(("Illegal union index for 'F783': "+ unionIndex783)); + } + } + int unionIndex784 = (decoder.readIndex()); + if (unionIndex784 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(784, null); + } else { + if (unionIndex784 == 1) { + Utf8 charSequence784; + Object oldString784 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(784); + if (oldString784 instanceof Utf8) { + charSequence784 = (decoder).readString(((Utf8) oldString784)); + } else { + charSequence784 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(784, charSequence784); + } else { + throw new RuntimeException(("Illegal union index for 'F784': "+ unionIndex784)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex785 = (decoder.readIndex()); + if (unionIndex785 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(785, null); + } else { + if (unionIndex785 == 1) { + Utf8 charSequence785; + Object oldString785 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(785); + if (oldString785 instanceof Utf8) { + charSequence785 = (decoder).readString(((Utf8) oldString785)); + } else { + charSequence785 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(785, charSequence785); + } else { + throw new RuntimeException(("Illegal union index for 'F785': "+ unionIndex785)); + } + } + int unionIndex786 = (decoder.readIndex()); + if (unionIndex786 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(786, null); + } else { + if (unionIndex786 == 1) { + Utf8 charSequence786; + Object oldString786 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(786); + if (oldString786 instanceof Utf8) { + charSequence786 = (decoder).readString(((Utf8) oldString786)); + } else { + charSequence786 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(786, charSequence786); + } else { + throw new RuntimeException(("Illegal union index for 'F786': "+ unionIndex786)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex787 = (decoder.readIndex()); + if (unionIndex787 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(787, null); + } else { + if (unionIndex787 == 1) { + Utf8 charSequence787; + Object oldString787 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(787); + if (oldString787 instanceof Utf8) { + charSequence787 = (decoder).readString(((Utf8) oldString787)); + } else { + charSequence787 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(787, charSequence787); + } else { + throw new RuntimeException(("Illegal union index for 'F787': "+ unionIndex787)); + } + } + int unionIndex788 = (decoder.readIndex()); + if (unionIndex788 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(788, null); + } else { + if (unionIndex788 == 1) { + Utf8 charSequence788; + Object oldString788 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(788); + if (oldString788 instanceof Utf8) { + charSequence788 = (decoder).readString(((Utf8) oldString788)); + } else { + charSequence788 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(788, charSequence788); + } else { + throw new RuntimeException(("Illegal union index for 'F788': "+ unionIndex788)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex789 = (decoder.readIndex()); + if (unionIndex789 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(789, null); + } else { + if (unionIndex789 == 1) { + Utf8 charSequence789; + Object oldString789 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(789); + if (oldString789 instanceof Utf8) { + charSequence789 = (decoder).readString(((Utf8) oldString789)); + } else { + charSequence789 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(789, charSequence789); + } else { + throw new RuntimeException(("Illegal union index for 'F789': "+ unionIndex789)); + } + } + int unionIndex790 = (decoder.readIndex()); + if (unionIndex790 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(790, null); + } else { + if (unionIndex790 == 1) { + Utf8 charSequence790; + Object oldString790 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(790); + if (oldString790 instanceof Utf8) { + charSequence790 = (decoder).readString(((Utf8) oldString790)); + } else { + charSequence790 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(790, charSequence790); + } else { + throw new RuntimeException(("Illegal union index for 'F790': "+ unionIndex790)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex791 = (decoder.readIndex()); + if (unionIndex791 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(791, null); + } else { + if (unionIndex791 == 1) { + Utf8 charSequence791; + Object oldString791 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(791); + if (oldString791 instanceof Utf8) { + charSequence791 = (decoder).readString(((Utf8) oldString791)); + } else { + charSequence791 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(791, charSequence791); + } else { + throw new RuntimeException(("Illegal union index for 'F791': "+ unionIndex791)); + } + } + int unionIndex792 = (decoder.readIndex()); + if (unionIndex792 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(792, null); + } else { + if (unionIndex792 == 1) { + Utf8 charSequence792; + Object oldString792 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(792); + if (oldString792 instanceof Utf8) { + charSequence792 = (decoder).readString(((Utf8) oldString792)); + } else { + charSequence792 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(792, charSequence792); + } else { + throw new RuntimeException(("Illegal union index for 'F792': "+ unionIndex792)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex793 = (decoder.readIndex()); + if (unionIndex793 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(793, null); + } else { + if (unionIndex793 == 1) { + Utf8 charSequence793; + Object oldString793 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(793); + if (oldString793 instanceof Utf8) { + charSequence793 = (decoder).readString(((Utf8) oldString793)); + } else { + charSequence793 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(793, charSequence793); + } else { + throw new RuntimeException(("Illegal union index for 'F793': "+ unionIndex793)); + } + } + int unionIndex794 = (decoder.readIndex()); + if (unionIndex794 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(794, null); + } else { + if (unionIndex794 == 1) { + Utf8 charSequence794; + Object oldString794 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(794); + if (oldString794 instanceof Utf8) { + charSequence794 = (decoder).readString(((Utf8) oldString794)); + } else { + charSequence794 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(794, charSequence794); + } else { + throw new RuntimeException(("Illegal union index for 'F794': "+ unionIndex794)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex795 = (decoder.readIndex()); + if (unionIndex795 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(795, null); + } else { + if (unionIndex795 == 1) { + Utf8 charSequence795; + Object oldString795 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(795); + if (oldString795 instanceof Utf8) { + charSequence795 = (decoder).readString(((Utf8) oldString795)); + } else { + charSequence795 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(795, charSequence795); + } else { + throw new RuntimeException(("Illegal union index for 'F795': "+ unionIndex795)); + } + } + int unionIndex796 = (decoder.readIndex()); + if (unionIndex796 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(796, null); + } else { + if (unionIndex796 == 1) { + Utf8 charSequence796; + Object oldString796 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(796); + if (oldString796 instanceof Utf8) { + charSequence796 = (decoder).readString(((Utf8) oldString796)); + } else { + charSequence796 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(796, charSequence796); + } else { + throw new RuntimeException(("Illegal union index for 'F796': "+ unionIndex796)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex797 = (decoder.readIndex()); + if (unionIndex797 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(797, null); + } else { + if (unionIndex797 == 1) { + Utf8 charSequence797; + Object oldString797 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(797); + if (oldString797 instanceof Utf8) { + charSequence797 = (decoder).readString(((Utf8) oldString797)); + } else { + charSequence797 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(797, charSequence797); + } else { + throw new RuntimeException(("Illegal union index for 'F797': "+ unionIndex797)); + } + } + int unionIndex798 = (decoder.readIndex()); + if (unionIndex798 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(798, null); + } else { + if (unionIndex798 == 1) { + Utf8 charSequence798; + Object oldString798 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(798); + if (oldString798 instanceof Utf8) { + charSequence798 = (decoder).readString(((Utf8) oldString798)); + } else { + charSequence798 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(798, charSequence798); + } else { + throw new RuntimeException(("Illegal union index for 'F798': "+ unionIndex798)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex799 = (decoder.readIndex()); + if (unionIndex799 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(799, null); + } else { + if (unionIndex799 == 1) { + Utf8 charSequence799; + Object oldString799 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(799); + if (oldString799 instanceof Utf8) { + charSequence799 = (decoder).readString(((Utf8) oldString799)); + } else { + charSequence799 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(799, charSequence799); + } else { + throw new RuntimeException(("Illegal union index for 'F799': "+ unionIndex799)); + } + } + int unionIndex800 = (decoder.readIndex()); + if (unionIndex800 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(800, null); + } else { + if (unionIndex800 == 1) { + Utf8 charSequence800; + Object oldString800 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(800); + if (oldString800 instanceof Utf8) { + charSequence800 = (decoder).readString(((Utf8) oldString800)); + } else { + charSequence800 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(800, charSequence800); + } else { + throw new RuntimeException(("Illegal union index for 'F800': "+ unionIndex800)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex801 = (decoder.readIndex()); + if (unionIndex801 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(801, null); + } else { + if (unionIndex801 == 1) { + Utf8 charSequence801; + Object oldString801 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(801); + if (oldString801 instanceof Utf8) { + charSequence801 = (decoder).readString(((Utf8) oldString801)); + } else { + charSequence801 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(801, charSequence801); + } else { + throw new RuntimeException(("Illegal union index for 'F801': "+ unionIndex801)); + } + } + int unionIndex802 = (decoder.readIndex()); + if (unionIndex802 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(802, null); + } else { + if (unionIndex802 == 1) { + Utf8 charSequence802; + Object oldString802 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(802); + if (oldString802 instanceof Utf8) { + charSequence802 = (decoder).readString(((Utf8) oldString802)); + } else { + charSequence802 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(802, charSequence802); + } else { + throw new RuntimeException(("Illegal union index for 'F802': "+ unionIndex802)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex803 = (decoder.readIndex()); + if (unionIndex803 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(803, null); + } else { + if (unionIndex803 == 1) { + Utf8 charSequence803; + Object oldString803 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(803); + if (oldString803 instanceof Utf8) { + charSequence803 = (decoder).readString(((Utf8) oldString803)); + } else { + charSequence803 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(803, charSequence803); + } else { + throw new RuntimeException(("Illegal union index for 'F803': "+ unionIndex803)); + } + } + int unionIndex804 = (decoder.readIndex()); + if (unionIndex804 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(804, null); + } else { + if (unionIndex804 == 1) { + Utf8 charSequence804; + Object oldString804 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(804); + if (oldString804 instanceof Utf8) { + charSequence804 = (decoder).readString(((Utf8) oldString804)); + } else { + charSequence804 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(804, charSequence804); + } else { + throw new RuntimeException(("Illegal union index for 'F804': "+ unionIndex804)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex805 = (decoder.readIndex()); + if (unionIndex805 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(805, null); + } else { + if (unionIndex805 == 1) { + Utf8 charSequence805; + Object oldString805 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(805); + if (oldString805 instanceof Utf8) { + charSequence805 = (decoder).readString(((Utf8) oldString805)); + } else { + charSequence805 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(805, charSequence805); + } else { + throw new RuntimeException(("Illegal union index for 'F805': "+ unionIndex805)); + } + } + int unionIndex806 = (decoder.readIndex()); + if (unionIndex806 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(806, null); + } else { + if (unionIndex806 == 1) { + Utf8 charSequence806; + Object oldString806 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(806); + if (oldString806 instanceof Utf8) { + charSequence806 = (decoder).readString(((Utf8) oldString806)); + } else { + charSequence806 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(806, charSequence806); + } else { + throw new RuntimeException(("Illegal union index for 'F806': "+ unionIndex806)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex807 = (decoder.readIndex()); + if (unionIndex807 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(807, null); + } else { + if (unionIndex807 == 1) { + Utf8 charSequence807; + Object oldString807 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(807); + if (oldString807 instanceof Utf8) { + charSequence807 = (decoder).readString(((Utf8) oldString807)); + } else { + charSequence807 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(807, charSequence807); + } else { + throw new RuntimeException(("Illegal union index for 'F807': "+ unionIndex807)); + } + } + int unionIndex808 = (decoder.readIndex()); + if (unionIndex808 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(808, null); + } else { + if (unionIndex808 == 1) { + Utf8 charSequence808; + Object oldString808 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(808); + if (oldString808 instanceof Utf8) { + charSequence808 = (decoder).readString(((Utf8) oldString808)); + } else { + charSequence808 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(808, charSequence808); + } else { + throw new RuntimeException(("Illegal union index for 'F808': "+ unionIndex808)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex809 = (decoder.readIndex()); + if (unionIndex809 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(809, null); + } else { + if (unionIndex809 == 1) { + Utf8 charSequence809; + Object oldString809 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(809); + if (oldString809 instanceof Utf8) { + charSequence809 = (decoder).readString(((Utf8) oldString809)); + } else { + charSequence809 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(809, charSequence809); + } else { + throw new RuntimeException(("Illegal union index for 'F809': "+ unionIndex809)); + } + } + int unionIndex810 = (decoder.readIndex()); + if (unionIndex810 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(810, null); + } else { + if (unionIndex810 == 1) { + Utf8 charSequence810; + Object oldString810 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(810); + if (oldString810 instanceof Utf8) { + charSequence810 = (decoder).readString(((Utf8) oldString810)); + } else { + charSequence810 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(810, charSequence810); + } else { + throw new RuntimeException(("Illegal union index for 'F810': "+ unionIndex810)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex811 = (decoder.readIndex()); + if (unionIndex811 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(811, null); + } else { + if (unionIndex811 == 1) { + Utf8 charSequence811; + Object oldString811 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(811); + if (oldString811 instanceof Utf8) { + charSequence811 = (decoder).readString(((Utf8) oldString811)); + } else { + charSequence811 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(811, charSequence811); + } else { + throw new RuntimeException(("Illegal union index for 'F811': "+ unionIndex811)); + } + } + int unionIndex812 = (decoder.readIndex()); + if (unionIndex812 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(812, null); + } else { + if (unionIndex812 == 1) { + Utf8 charSequence812; + Object oldString812 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(812); + if (oldString812 instanceof Utf8) { + charSequence812 = (decoder).readString(((Utf8) oldString812)); + } else { + charSequence812 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(812, charSequence812); + } else { + throw new RuntimeException(("Illegal union index for 'F812': "+ unionIndex812)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex813 = (decoder.readIndex()); + if (unionIndex813 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(813, null); + } else { + if (unionIndex813 == 1) { + Utf8 charSequence813; + Object oldString813 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(813); + if (oldString813 instanceof Utf8) { + charSequence813 = (decoder).readString(((Utf8) oldString813)); + } else { + charSequence813 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(813, charSequence813); + } else { + throw new RuntimeException(("Illegal union index for 'F813': "+ unionIndex813)); + } + } + int unionIndex814 = (decoder.readIndex()); + if (unionIndex814 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(814, null); + } else { + if (unionIndex814 == 1) { + Utf8 charSequence814; + Object oldString814 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(814); + if (oldString814 instanceof Utf8) { + charSequence814 = (decoder).readString(((Utf8) oldString814)); + } else { + charSequence814 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(814, charSequence814); + } else { + throw new RuntimeException(("Illegal union index for 'F814': "+ unionIndex814)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex815 = (decoder.readIndex()); + if (unionIndex815 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(815, null); + } else { + if (unionIndex815 == 1) { + Utf8 charSequence815; + Object oldString815 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(815); + if (oldString815 instanceof Utf8) { + charSequence815 = (decoder).readString(((Utf8) oldString815)); + } else { + charSequence815 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(815, charSequence815); + } else { + throw new RuntimeException(("Illegal union index for 'F815': "+ unionIndex815)); + } + } + int unionIndex816 = (decoder.readIndex()); + if (unionIndex816 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(816, null); + } else { + if (unionIndex816 == 1) { + Utf8 charSequence816; + Object oldString816 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(816); + if (oldString816 instanceof Utf8) { + charSequence816 = (decoder).readString(((Utf8) oldString816)); + } else { + charSequence816 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(816, charSequence816); + } else { + throw new RuntimeException(("Illegal union index for 'F816': "+ unionIndex816)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex817 = (decoder.readIndex()); + if (unionIndex817 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(817, null); + } else { + if (unionIndex817 == 1) { + Utf8 charSequence817; + Object oldString817 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(817); + if (oldString817 instanceof Utf8) { + charSequence817 = (decoder).readString(((Utf8) oldString817)); + } else { + charSequence817 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(817, charSequence817); + } else { + throw new RuntimeException(("Illegal union index for 'F817': "+ unionIndex817)); + } + } + int unionIndex818 = (decoder.readIndex()); + if (unionIndex818 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(818, null); + } else { + if (unionIndex818 == 1) { + Utf8 charSequence818; + Object oldString818 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(818); + if (oldString818 instanceof Utf8) { + charSequence818 = (decoder).readString(((Utf8) oldString818)); + } else { + charSequence818 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(818, charSequence818); + } else { + throw new RuntimeException(("Illegal union index for 'F818': "+ unionIndex818)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex819 = (decoder.readIndex()); + if (unionIndex819 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(819, null); + } else { + if (unionIndex819 == 1) { + Utf8 charSequence819; + Object oldString819 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(819); + if (oldString819 instanceof Utf8) { + charSequence819 = (decoder).readString(((Utf8) oldString819)); + } else { + charSequence819 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(819, charSequence819); + } else { + throw new RuntimeException(("Illegal union index for 'F819': "+ unionIndex819)); + } + } + int unionIndex820 = (decoder.readIndex()); + if (unionIndex820 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(820, null); + } else { + if (unionIndex820 == 1) { + Utf8 charSequence820; + Object oldString820 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(820); + if (oldString820 instanceof Utf8) { + charSequence820 = (decoder).readString(((Utf8) oldString820)); + } else { + charSequence820 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(820, charSequence820); + } else { + throw new RuntimeException(("Illegal union index for 'F820': "+ unionIndex820)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex821 = (decoder.readIndex()); + if (unionIndex821 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(821, null); + } else { + if (unionIndex821 == 1) { + Utf8 charSequence821; + Object oldString821 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(821); + if (oldString821 instanceof Utf8) { + charSequence821 = (decoder).readString(((Utf8) oldString821)); + } else { + charSequence821 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(821, charSequence821); + } else { + throw new RuntimeException(("Illegal union index for 'F821': "+ unionIndex821)); + } + } + int unionIndex822 = (decoder.readIndex()); + if (unionIndex822 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(822, null); + } else { + if (unionIndex822 == 1) { + Utf8 charSequence822; + Object oldString822 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(822); + if (oldString822 instanceof Utf8) { + charSequence822 = (decoder).readString(((Utf8) oldString822)); + } else { + charSequence822 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(822, charSequence822); + } else { + throw new RuntimeException(("Illegal union index for 'F822': "+ unionIndex822)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex823 = (decoder.readIndex()); + if (unionIndex823 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(823, null); + } else { + if (unionIndex823 == 1) { + Utf8 charSequence823; + Object oldString823 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(823); + if (oldString823 instanceof Utf8) { + charSequence823 = (decoder).readString(((Utf8) oldString823)); + } else { + charSequence823 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(823, charSequence823); + } else { + throw new RuntimeException(("Illegal union index for 'F823': "+ unionIndex823)); + } + } + int unionIndex824 = (decoder.readIndex()); + if (unionIndex824 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(824, null); + } else { + if (unionIndex824 == 1) { + Utf8 charSequence824; + Object oldString824 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(824); + if (oldString824 instanceof Utf8) { + charSequence824 = (decoder).readString(((Utf8) oldString824)); + } else { + charSequence824 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(824, charSequence824); + } else { + throw new RuntimeException(("Illegal union index for 'F824': "+ unionIndex824)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex825 = (decoder.readIndex()); + if (unionIndex825 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(825, null); + } else { + if (unionIndex825 == 1) { + Utf8 charSequence825; + Object oldString825 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(825); + if (oldString825 instanceof Utf8) { + charSequence825 = (decoder).readString(((Utf8) oldString825)); + } else { + charSequence825 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(825, charSequence825); + } else { + throw new RuntimeException(("Illegal union index for 'F825': "+ unionIndex825)); + } + } + int unionIndex826 = (decoder.readIndex()); + if (unionIndex826 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(826, null); + } else { + if (unionIndex826 == 1) { + Utf8 charSequence826; + Object oldString826 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(826); + if (oldString826 instanceof Utf8) { + charSequence826 = (decoder).readString(((Utf8) oldString826)); + } else { + charSequence826 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(826, charSequence826); + } else { + throw new RuntimeException(("Illegal union index for 'F826': "+ unionIndex826)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex827 = (decoder.readIndex()); + if (unionIndex827 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(827, null); + } else { + if (unionIndex827 == 1) { + Utf8 charSequence827; + Object oldString827 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(827); + if (oldString827 instanceof Utf8) { + charSequence827 = (decoder).readString(((Utf8) oldString827)); + } else { + charSequence827 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(827, charSequence827); + } else { + throw new RuntimeException(("Illegal union index for 'F827': "+ unionIndex827)); + } + } + int unionIndex828 = (decoder.readIndex()); + if (unionIndex828 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(828, null); + } else { + if (unionIndex828 == 1) { + Utf8 charSequence828; + Object oldString828 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(828); + if (oldString828 instanceof Utf8) { + charSequence828 = (decoder).readString(((Utf8) oldString828)); + } else { + charSequence828 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(828, charSequence828); + } else { + throw new RuntimeException(("Illegal union index for 'F828': "+ unionIndex828)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex829 = (decoder.readIndex()); + if (unionIndex829 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(829, null); + } else { + if (unionIndex829 == 1) { + Utf8 charSequence829; + Object oldString829 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(829); + if (oldString829 instanceof Utf8) { + charSequence829 = (decoder).readString(((Utf8) oldString829)); + } else { + charSequence829 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(829, charSequence829); + } else { + throw new RuntimeException(("Illegal union index for 'F829': "+ unionIndex829)); + } + } + int unionIndex830 = (decoder.readIndex()); + if (unionIndex830 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(830, null); + } else { + if (unionIndex830 == 1) { + Utf8 charSequence830; + Object oldString830 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(830); + if (oldString830 instanceof Utf8) { + charSequence830 = (decoder).readString(((Utf8) oldString830)); + } else { + charSequence830 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(830, charSequence830); + } else { + throw new RuntimeException(("Illegal union index for 'F830': "+ unionIndex830)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex831 = (decoder.readIndex()); + if (unionIndex831 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(831, null); + } else { + if (unionIndex831 == 1) { + Utf8 charSequence831; + Object oldString831 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(831); + if (oldString831 instanceof Utf8) { + charSequence831 = (decoder).readString(((Utf8) oldString831)); + } else { + charSequence831 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(831, charSequence831); + } else { + throw new RuntimeException(("Illegal union index for 'F831': "+ unionIndex831)); + } + } + int unionIndex832 = (decoder.readIndex()); + if (unionIndex832 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(832, null); + } else { + if (unionIndex832 == 1) { + Utf8 charSequence832; + Object oldString832 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(832); + if (oldString832 instanceof Utf8) { + charSequence832 = (decoder).readString(((Utf8) oldString832)); + } else { + charSequence832 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(832, charSequence832); + } else { + throw new RuntimeException(("Illegal union index for 'F832': "+ unionIndex832)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex833 = (decoder.readIndex()); + if (unionIndex833 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(833, null); + } else { + if (unionIndex833 == 1) { + Utf8 charSequence833; + Object oldString833 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(833); + if (oldString833 instanceof Utf8) { + charSequence833 = (decoder).readString(((Utf8) oldString833)); + } else { + charSequence833 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(833, charSequence833); + } else { + throw new RuntimeException(("Illegal union index for 'F833': "+ unionIndex833)); + } + } + int unionIndex834 = (decoder.readIndex()); + if (unionIndex834 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(834, null); + } else { + if (unionIndex834 == 1) { + Utf8 charSequence834; + Object oldString834 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(834); + if (oldString834 instanceof Utf8) { + charSequence834 = (decoder).readString(((Utf8) oldString834)); + } else { + charSequence834 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(834, charSequence834); + } else { + throw new RuntimeException(("Illegal union index for 'F834': "+ unionIndex834)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex835 = (decoder.readIndex()); + if (unionIndex835 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(835, null); + } else { + if (unionIndex835 == 1) { + Utf8 charSequence835; + Object oldString835 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(835); + if (oldString835 instanceof Utf8) { + charSequence835 = (decoder).readString(((Utf8) oldString835)); + } else { + charSequence835 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(835, charSequence835); + } else { + throw new RuntimeException(("Illegal union index for 'F835': "+ unionIndex835)); + } + } + int unionIndex836 = (decoder.readIndex()); + if (unionIndex836 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(836, null); + } else { + if (unionIndex836 == 1) { + Utf8 charSequence836; + Object oldString836 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(836); + if (oldString836 instanceof Utf8) { + charSequence836 = (decoder).readString(((Utf8) oldString836)); + } else { + charSequence836 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(836, charSequence836); + } else { + throw new RuntimeException(("Illegal union index for 'F836': "+ unionIndex836)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex837 = (decoder.readIndex()); + if (unionIndex837 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(837, null); + } else { + if (unionIndex837 == 1) { + Utf8 charSequence837; + Object oldString837 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(837); + if (oldString837 instanceof Utf8) { + charSequence837 = (decoder).readString(((Utf8) oldString837)); + } else { + charSequence837 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(837, charSequence837); + } else { + throw new RuntimeException(("Illegal union index for 'F837': "+ unionIndex837)); + } + } + int unionIndex838 = (decoder.readIndex()); + if (unionIndex838 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(838, null); + } else { + if (unionIndex838 == 1) { + Utf8 charSequence838; + Object oldString838 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(838); + if (oldString838 instanceof Utf8) { + charSequence838 = (decoder).readString(((Utf8) oldString838)); + } else { + charSequence838 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(838, charSequence838); + } else { + throw new RuntimeException(("Illegal union index for 'F838': "+ unionIndex838)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex839 = (decoder.readIndex()); + if (unionIndex839 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(839, null); + } else { + if (unionIndex839 == 1) { + Utf8 charSequence839; + Object oldString839 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(839); + if (oldString839 instanceof Utf8) { + charSequence839 = (decoder).readString(((Utf8) oldString839)); + } else { + charSequence839 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(839, charSequence839); + } else { + throw new RuntimeException(("Illegal union index for 'F839': "+ unionIndex839)); + } + } + int unionIndex840 = (decoder.readIndex()); + if (unionIndex840 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(840, null); + } else { + if (unionIndex840 == 1) { + Utf8 charSequence840; + Object oldString840 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(840); + if (oldString840 instanceof Utf8) { + charSequence840 = (decoder).readString(((Utf8) oldString840)); + } else { + charSequence840 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(840, charSequence840); + } else { + throw new RuntimeException(("Illegal union index for 'F840': "+ unionIndex840)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex841 = (decoder.readIndex()); + if (unionIndex841 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(841, null); + } else { + if (unionIndex841 == 1) { + Utf8 charSequence841; + Object oldString841 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(841); + if (oldString841 instanceof Utf8) { + charSequence841 = (decoder).readString(((Utf8) oldString841)); + } else { + charSequence841 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(841, charSequence841); + } else { + throw new RuntimeException(("Illegal union index for 'F841': "+ unionIndex841)); + } + } + int unionIndex842 = (decoder.readIndex()); + if (unionIndex842 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(842, null); + } else { + if (unionIndex842 == 1) { + Utf8 charSequence842; + Object oldString842 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(842); + if (oldString842 instanceof Utf8) { + charSequence842 = (decoder).readString(((Utf8) oldString842)); + } else { + charSequence842 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(842, charSequence842); + } else { + throw new RuntimeException(("Illegal union index for 'F842': "+ unionIndex842)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex843 = (decoder.readIndex()); + if (unionIndex843 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(843, null); + } else { + if (unionIndex843 == 1) { + Utf8 charSequence843; + Object oldString843 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(843); + if (oldString843 instanceof Utf8) { + charSequence843 = (decoder).readString(((Utf8) oldString843)); + } else { + charSequence843 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(843, charSequence843); + } else { + throw new RuntimeException(("Illegal union index for 'F843': "+ unionIndex843)); + } + } + int unionIndex844 = (decoder.readIndex()); + if (unionIndex844 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(844, null); + } else { + if (unionIndex844 == 1) { + Utf8 charSequence844; + Object oldString844 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(844); + if (oldString844 instanceof Utf8) { + charSequence844 = (decoder).readString(((Utf8) oldString844)); + } else { + charSequence844 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(844, charSequence844); + } else { + throw new RuntimeException(("Illegal union index for 'F844': "+ unionIndex844)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex845 = (decoder.readIndex()); + if (unionIndex845 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(845, null); + } else { + if (unionIndex845 == 1) { + Utf8 charSequence845; + Object oldString845 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(845); + if (oldString845 instanceof Utf8) { + charSequence845 = (decoder).readString(((Utf8) oldString845)); + } else { + charSequence845 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(845, charSequence845); + } else { + throw new RuntimeException(("Illegal union index for 'F845': "+ unionIndex845)); + } + } + int unionIndex846 = (decoder.readIndex()); + if (unionIndex846 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(846, null); + } else { + if (unionIndex846 == 1) { + Utf8 charSequence846; + Object oldString846 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(846); + if (oldString846 instanceof Utf8) { + charSequence846 = (decoder).readString(((Utf8) oldString846)); + } else { + charSequence846 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(846, charSequence846); + } else { + throw new RuntimeException(("Illegal union index for 'F846': "+ unionIndex846)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex847 = (decoder.readIndex()); + if (unionIndex847 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(847, null); + } else { + if (unionIndex847 == 1) { + Utf8 charSequence847; + Object oldString847 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(847); + if (oldString847 instanceof Utf8) { + charSequence847 = (decoder).readString(((Utf8) oldString847)); + } else { + charSequence847 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(847, charSequence847); + } else { + throw new RuntimeException(("Illegal union index for 'F847': "+ unionIndex847)); + } + } + int unionIndex848 = (decoder.readIndex()); + if (unionIndex848 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(848, null); + } else { + if (unionIndex848 == 1) { + Utf8 charSequence848; + Object oldString848 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(848); + if (oldString848 instanceof Utf8) { + charSequence848 = (decoder).readString(((Utf8) oldString848)); + } else { + charSequence848 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(848, charSequence848); + } else { + throw new RuntimeException(("Illegal union index for 'F848': "+ unionIndex848)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex849 = (decoder.readIndex()); + if (unionIndex849 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(849, null); + } else { + if (unionIndex849 == 1) { + Utf8 charSequence849; + Object oldString849 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(849); + if (oldString849 instanceof Utf8) { + charSequence849 = (decoder).readString(((Utf8) oldString849)); + } else { + charSequence849 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(849, charSequence849); + } else { + throw new RuntimeException(("Illegal union index for 'F849': "+ unionIndex849)); + } + } + int unionIndex850 = (decoder.readIndex()); + if (unionIndex850 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(850, null); + } else { + if (unionIndex850 == 1) { + Utf8 charSequence850; + Object oldString850 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(850); + if (oldString850 instanceof Utf8) { + charSequence850 = (decoder).readString(((Utf8) oldString850)); + } else { + charSequence850 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(850, charSequence850); + } else { + throw new RuntimeException(("Illegal union index for 'F850': "+ unionIndex850)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex851 = (decoder.readIndex()); + if (unionIndex851 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(851, null); + } else { + if (unionIndex851 == 1) { + Utf8 charSequence851; + Object oldString851 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(851); + if (oldString851 instanceof Utf8) { + charSequence851 = (decoder).readString(((Utf8) oldString851)); + } else { + charSequence851 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(851, charSequence851); + } else { + throw new RuntimeException(("Illegal union index for 'F851': "+ unionIndex851)); + } + } + int unionIndex852 = (decoder.readIndex()); + if (unionIndex852 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(852, null); + } else { + if (unionIndex852 == 1) { + Utf8 charSequence852; + Object oldString852 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(852); + if (oldString852 instanceof Utf8) { + charSequence852 = (decoder).readString(((Utf8) oldString852)); + } else { + charSequence852 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(852, charSequence852); + } else { + throw new RuntimeException(("Illegal union index for 'F852': "+ unionIndex852)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex853 = (decoder.readIndex()); + if (unionIndex853 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(853, null); + } else { + if (unionIndex853 == 1) { + Utf8 charSequence853; + Object oldString853 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(853); + if (oldString853 instanceof Utf8) { + charSequence853 = (decoder).readString(((Utf8) oldString853)); + } else { + charSequence853 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(853, charSequence853); + } else { + throw new RuntimeException(("Illegal union index for 'F853': "+ unionIndex853)); + } + } + int unionIndex854 = (decoder.readIndex()); + if (unionIndex854 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(854, null); + } else { + if (unionIndex854 == 1) { + Utf8 charSequence854; + Object oldString854 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(854); + if (oldString854 instanceof Utf8) { + charSequence854 = (decoder).readString(((Utf8) oldString854)); + } else { + charSequence854 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(854, charSequence854); + } else { + throw new RuntimeException(("Illegal union index for 'F854': "+ unionIndex854)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex855 = (decoder.readIndex()); + if (unionIndex855 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(855, null); + } else { + if (unionIndex855 == 1) { + Utf8 charSequence855; + Object oldString855 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(855); + if (oldString855 instanceof Utf8) { + charSequence855 = (decoder).readString(((Utf8) oldString855)); + } else { + charSequence855 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(855, charSequence855); + } else { + throw new RuntimeException(("Illegal union index for 'F855': "+ unionIndex855)); + } + } + int unionIndex856 = (decoder.readIndex()); + if (unionIndex856 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(856, null); + } else { + if (unionIndex856 == 1) { + Utf8 charSequence856; + Object oldString856 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(856); + if (oldString856 instanceof Utf8) { + charSequence856 = (decoder).readString(((Utf8) oldString856)); + } else { + charSequence856 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(856, charSequence856); + } else { + throw new RuntimeException(("Illegal union index for 'F856': "+ unionIndex856)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex857 = (decoder.readIndex()); + if (unionIndex857 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(857, null); + } else { + if (unionIndex857 == 1) { + Utf8 charSequence857; + Object oldString857 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(857); + if (oldString857 instanceof Utf8) { + charSequence857 = (decoder).readString(((Utf8) oldString857)); + } else { + charSequence857 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(857, charSequence857); + } else { + throw new RuntimeException(("Illegal union index for 'F857': "+ unionIndex857)); + } + } + int unionIndex858 = (decoder.readIndex()); + if (unionIndex858 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(858, null); + } else { + if (unionIndex858 == 1) { + Utf8 charSequence858; + Object oldString858 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(858); + if (oldString858 instanceof Utf8) { + charSequence858 = (decoder).readString(((Utf8) oldString858)); + } else { + charSequence858 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(858, charSequence858); + } else { + throw new RuntimeException(("Illegal union index for 'F858': "+ unionIndex858)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex859 = (decoder.readIndex()); + if (unionIndex859 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(859, null); + } else { + if (unionIndex859 == 1) { + Utf8 charSequence859; + Object oldString859 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(859); + if (oldString859 instanceof Utf8) { + charSequence859 = (decoder).readString(((Utf8) oldString859)); + } else { + charSequence859 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(859, charSequence859); + } else { + throw new RuntimeException(("Illegal union index for 'F859': "+ unionIndex859)); + } + } + int unionIndex860 = (decoder.readIndex()); + if (unionIndex860 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(860, null); + } else { + if (unionIndex860 == 1) { + Utf8 charSequence860; + Object oldString860 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(860); + if (oldString860 instanceof Utf8) { + charSequence860 = (decoder).readString(((Utf8) oldString860)); + } else { + charSequence860 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(860, charSequence860); + } else { + throw new RuntimeException(("Illegal union index for 'F860': "+ unionIndex860)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex861 = (decoder.readIndex()); + if (unionIndex861 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(861, null); + } else { + if (unionIndex861 == 1) { + Utf8 charSequence861; + Object oldString861 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(861); + if (oldString861 instanceof Utf8) { + charSequence861 = (decoder).readString(((Utf8) oldString861)); + } else { + charSequence861 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(861, charSequence861); + } else { + throw new RuntimeException(("Illegal union index for 'F861': "+ unionIndex861)); + } + } + int unionIndex862 = (decoder.readIndex()); + if (unionIndex862 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(862, null); + } else { + if (unionIndex862 == 1) { + Utf8 charSequence862; + Object oldString862 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(862); + if (oldString862 instanceof Utf8) { + charSequence862 = (decoder).readString(((Utf8) oldString862)); + } else { + charSequence862 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(862, charSequence862); + } else { + throw new RuntimeException(("Illegal union index for 'F862': "+ unionIndex862)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex863 = (decoder.readIndex()); + if (unionIndex863 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(863, null); + } else { + if (unionIndex863 == 1) { + Utf8 charSequence863; + Object oldString863 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(863); + if (oldString863 instanceof Utf8) { + charSequence863 = (decoder).readString(((Utf8) oldString863)); + } else { + charSequence863 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(863, charSequence863); + } else { + throw new RuntimeException(("Illegal union index for 'F863': "+ unionIndex863)); + } + } + int unionIndex864 = (decoder.readIndex()); + if (unionIndex864 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(864, null); + } else { + if (unionIndex864 == 1) { + Utf8 charSequence864; + Object oldString864 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(864); + if (oldString864 instanceof Utf8) { + charSequence864 = (decoder).readString(((Utf8) oldString864)); + } else { + charSequence864 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(864, charSequence864); + } else { + throw new RuntimeException(("Illegal union index for 'F864': "+ unionIndex864)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex865 = (decoder.readIndex()); + if (unionIndex865 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(865, null); + } else { + if (unionIndex865 == 1) { + Utf8 charSequence865; + Object oldString865 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(865); + if (oldString865 instanceof Utf8) { + charSequence865 = (decoder).readString(((Utf8) oldString865)); + } else { + charSequence865 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(865, charSequence865); + } else { + throw new RuntimeException(("Illegal union index for 'F865': "+ unionIndex865)); + } + } + int unionIndex866 = (decoder.readIndex()); + if (unionIndex866 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(866, null); + } else { + if (unionIndex866 == 1) { + Utf8 charSequence866; + Object oldString866 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(866); + if (oldString866 instanceof Utf8) { + charSequence866 = (decoder).readString(((Utf8) oldString866)); + } else { + charSequence866 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(866, charSequence866); + } else { + throw new RuntimeException(("Illegal union index for 'F866': "+ unionIndex866)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex867 = (decoder.readIndex()); + if (unionIndex867 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(867, null); + } else { + if (unionIndex867 == 1) { + Utf8 charSequence867; + Object oldString867 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(867); + if (oldString867 instanceof Utf8) { + charSequence867 = (decoder).readString(((Utf8) oldString867)); + } else { + charSequence867 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(867, charSequence867); + } else { + throw new RuntimeException(("Illegal union index for 'F867': "+ unionIndex867)); + } + } + int unionIndex868 = (decoder.readIndex()); + if (unionIndex868 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(868, null); + } else { + if (unionIndex868 == 1) { + Utf8 charSequence868; + Object oldString868 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(868); + if (oldString868 instanceof Utf8) { + charSequence868 = (decoder).readString(((Utf8) oldString868)); + } else { + charSequence868 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(868, charSequence868); + } else { + throw new RuntimeException(("Illegal union index for 'F868': "+ unionIndex868)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex869 = (decoder.readIndex()); + if (unionIndex869 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(869, null); + } else { + if (unionIndex869 == 1) { + Utf8 charSequence869; + Object oldString869 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(869); + if (oldString869 instanceof Utf8) { + charSequence869 = (decoder).readString(((Utf8) oldString869)); + } else { + charSequence869 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(869, charSequence869); + } else { + throw new RuntimeException(("Illegal union index for 'F869': "+ unionIndex869)); + } + } + int unionIndex870 = (decoder.readIndex()); + if (unionIndex870 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(870, null); + } else { + if (unionIndex870 == 1) { + Utf8 charSequence870; + Object oldString870 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(870); + if (oldString870 instanceof Utf8) { + charSequence870 = (decoder).readString(((Utf8) oldString870)); + } else { + charSequence870 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(870, charSequence870); + } else { + throw new RuntimeException(("Illegal union index for 'F870': "+ unionIndex870)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex871 = (decoder.readIndex()); + if (unionIndex871 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(871, null); + } else { + if (unionIndex871 == 1) { + Utf8 charSequence871; + Object oldString871 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(871); + if (oldString871 instanceof Utf8) { + charSequence871 = (decoder).readString(((Utf8) oldString871)); + } else { + charSequence871 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(871, charSequence871); + } else { + throw new RuntimeException(("Illegal union index for 'F871': "+ unionIndex871)); + } + } + int unionIndex872 = (decoder.readIndex()); + if (unionIndex872 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(872, null); + } else { + if (unionIndex872 == 1) { + Utf8 charSequence872; + Object oldString872 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(872); + if (oldString872 instanceof Utf8) { + charSequence872 = (decoder).readString(((Utf8) oldString872)); + } else { + charSequence872 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(872, charSequence872); + } else { + throw new RuntimeException(("Illegal union index for 'F872': "+ unionIndex872)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex873 = (decoder.readIndex()); + if (unionIndex873 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(873, null); + } else { + if (unionIndex873 == 1) { + Utf8 charSequence873; + Object oldString873 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(873); + if (oldString873 instanceof Utf8) { + charSequence873 = (decoder).readString(((Utf8) oldString873)); + } else { + charSequence873 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(873, charSequence873); + } else { + throw new RuntimeException(("Illegal union index for 'F873': "+ unionIndex873)); + } + } + int unionIndex874 = (decoder.readIndex()); + if (unionIndex874 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(874, null); + } else { + if (unionIndex874 == 1) { + Utf8 charSequence874; + Object oldString874 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(874); + if (oldString874 instanceof Utf8) { + charSequence874 = (decoder).readString(((Utf8) oldString874)); + } else { + charSequence874 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(874, charSequence874); + } else { + throw new RuntimeException(("Illegal union index for 'F874': "+ unionIndex874)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex875 = (decoder.readIndex()); + if (unionIndex875 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(875, null); + } else { + if (unionIndex875 == 1) { + Utf8 charSequence875; + Object oldString875 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(875); + if (oldString875 instanceof Utf8) { + charSequence875 = (decoder).readString(((Utf8) oldString875)); + } else { + charSequence875 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(875, charSequence875); + } else { + throw new RuntimeException(("Illegal union index for 'F875': "+ unionIndex875)); + } + } + int unionIndex876 = (decoder.readIndex()); + if (unionIndex876 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(876, null); + } else { + if (unionIndex876 == 1) { + Utf8 charSequence876; + Object oldString876 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(876); + if (oldString876 instanceof Utf8) { + charSequence876 = (decoder).readString(((Utf8) oldString876)); + } else { + charSequence876 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(876, charSequence876); + } else { + throw new RuntimeException(("Illegal union index for 'F876': "+ unionIndex876)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex877 = (decoder.readIndex()); + if (unionIndex877 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(877, null); + } else { + if (unionIndex877 == 1) { + Utf8 charSequence877; + Object oldString877 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(877); + if (oldString877 instanceof Utf8) { + charSequence877 = (decoder).readString(((Utf8) oldString877)); + } else { + charSequence877 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(877, charSequence877); + } else { + throw new RuntimeException(("Illegal union index for 'F877': "+ unionIndex877)); + } + } + int unionIndex878 = (decoder.readIndex()); + if (unionIndex878 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(878, null); + } else { + if (unionIndex878 == 1) { + Utf8 charSequence878; + Object oldString878 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(878); + if (oldString878 instanceof Utf8) { + charSequence878 = (decoder).readString(((Utf8) oldString878)); + } else { + charSequence878 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(878, charSequence878); + } else { + throw new RuntimeException(("Illegal union index for 'F878': "+ unionIndex878)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex879 = (decoder.readIndex()); + if (unionIndex879 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(879, null); + } else { + if (unionIndex879 == 1) { + Utf8 charSequence879; + Object oldString879 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(879); + if (oldString879 instanceof Utf8) { + charSequence879 = (decoder).readString(((Utf8) oldString879)); + } else { + charSequence879 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(879, charSequence879); + } else { + throw new RuntimeException(("Illegal union index for 'F879': "+ unionIndex879)); + } + } + int unionIndex880 = (decoder.readIndex()); + if (unionIndex880 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(880, null); + } else { + if (unionIndex880 == 1) { + Utf8 charSequence880; + Object oldString880 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(880); + if (oldString880 instanceof Utf8) { + charSequence880 = (decoder).readString(((Utf8) oldString880)); + } else { + charSequence880 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(880, charSequence880); + } else { + throw new RuntimeException(("Illegal union index for 'F880': "+ unionIndex880)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex881 = (decoder.readIndex()); + if (unionIndex881 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(881, null); + } else { + if (unionIndex881 == 1) { + Utf8 charSequence881; + Object oldString881 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(881); + if (oldString881 instanceof Utf8) { + charSequence881 = (decoder).readString(((Utf8) oldString881)); + } else { + charSequence881 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(881, charSequence881); + } else { + throw new RuntimeException(("Illegal union index for 'F881': "+ unionIndex881)); + } + } + int unionIndex882 = (decoder.readIndex()); + if (unionIndex882 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(882, null); + } else { + if (unionIndex882 == 1) { + Utf8 charSequence882; + Object oldString882 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(882); + if (oldString882 instanceof Utf8) { + charSequence882 = (decoder).readString(((Utf8) oldString882)); + } else { + charSequence882 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(882, charSequence882); + } else { + throw new RuntimeException(("Illegal union index for 'F882': "+ unionIndex882)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex883 = (decoder.readIndex()); + if (unionIndex883 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(883, null); + } else { + if (unionIndex883 == 1) { + Utf8 charSequence883; + Object oldString883 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(883); + if (oldString883 instanceof Utf8) { + charSequence883 = (decoder).readString(((Utf8) oldString883)); + } else { + charSequence883 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(883, charSequence883); + } else { + throw new RuntimeException(("Illegal union index for 'F883': "+ unionIndex883)); + } + } + int unionIndex884 = (decoder.readIndex()); + if (unionIndex884 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(884, null); + } else { + if (unionIndex884 == 1) { + Utf8 charSequence884; + Object oldString884 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(884); + if (oldString884 instanceof Utf8) { + charSequence884 = (decoder).readString(((Utf8) oldString884)); + } else { + charSequence884 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(884, charSequence884); + } else { + throw new RuntimeException(("Illegal union index for 'F884': "+ unionIndex884)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex885 = (decoder.readIndex()); + if (unionIndex885 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(885, null); + } else { + if (unionIndex885 == 1) { + Utf8 charSequence885; + Object oldString885 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(885); + if (oldString885 instanceof Utf8) { + charSequence885 = (decoder).readString(((Utf8) oldString885)); + } else { + charSequence885 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(885, charSequence885); + } else { + throw new RuntimeException(("Illegal union index for 'F885': "+ unionIndex885)); + } + } + int unionIndex886 = (decoder.readIndex()); + if (unionIndex886 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(886, null); + } else { + if (unionIndex886 == 1) { + Utf8 charSequence886; + Object oldString886 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(886); + if (oldString886 instanceof Utf8) { + charSequence886 = (decoder).readString(((Utf8) oldString886)); + } else { + charSequence886 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(886, charSequence886); + } else { + throw new RuntimeException(("Illegal union index for 'F886': "+ unionIndex886)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex887 = (decoder.readIndex()); + if (unionIndex887 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(887, null); + } else { + if (unionIndex887 == 1) { + Utf8 charSequence887; + Object oldString887 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(887); + if (oldString887 instanceof Utf8) { + charSequence887 = (decoder).readString(((Utf8) oldString887)); + } else { + charSequence887 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(887, charSequence887); + } else { + throw new RuntimeException(("Illegal union index for 'F887': "+ unionIndex887)); + } + } + int unionIndex888 = (decoder.readIndex()); + if (unionIndex888 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(888, null); + } else { + if (unionIndex888 == 1) { + Utf8 charSequence888; + Object oldString888 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(888); + if (oldString888 instanceof Utf8) { + charSequence888 = (decoder).readString(((Utf8) oldString888)); + } else { + charSequence888 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(888, charSequence888); + } else { + throw new RuntimeException(("Illegal union index for 'F888': "+ unionIndex888)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex889 = (decoder.readIndex()); + if (unionIndex889 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(889, null); + } else { + if (unionIndex889 == 1) { + Utf8 charSequence889; + Object oldString889 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(889); + if (oldString889 instanceof Utf8) { + charSequence889 = (decoder).readString(((Utf8) oldString889)); + } else { + charSequence889 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(889, charSequence889); + } else { + throw new RuntimeException(("Illegal union index for 'F889': "+ unionIndex889)); + } + } + int unionIndex890 = (decoder.readIndex()); + if (unionIndex890 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(890, null); + } else { + if (unionIndex890 == 1) { + Utf8 charSequence890; + Object oldString890 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(890); + if (oldString890 instanceof Utf8) { + charSequence890 = (decoder).readString(((Utf8) oldString890)); + } else { + charSequence890 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(890, charSequence890); + } else { + throw new RuntimeException(("Illegal union index for 'F890': "+ unionIndex890)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex891 = (decoder.readIndex()); + if (unionIndex891 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(891, null); + } else { + if (unionIndex891 == 1) { + Utf8 charSequence891; + Object oldString891 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(891); + if (oldString891 instanceof Utf8) { + charSequence891 = (decoder).readString(((Utf8) oldString891)); + } else { + charSequence891 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(891, charSequence891); + } else { + throw new RuntimeException(("Illegal union index for 'F891': "+ unionIndex891)); + } + } + int unionIndex892 = (decoder.readIndex()); + if (unionIndex892 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(892, null); + } else { + if (unionIndex892 == 1) { + Utf8 charSequence892; + Object oldString892 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(892); + if (oldString892 instanceof Utf8) { + charSequence892 = (decoder).readString(((Utf8) oldString892)); + } else { + charSequence892 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(892, charSequence892); + } else { + throw new RuntimeException(("Illegal union index for 'F892': "+ unionIndex892)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex893 = (decoder.readIndex()); + if (unionIndex893 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(893, null); + } else { + if (unionIndex893 == 1) { + Utf8 charSequence893; + Object oldString893 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(893); + if (oldString893 instanceof Utf8) { + charSequence893 = (decoder).readString(((Utf8) oldString893)); + } else { + charSequence893 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(893, charSequence893); + } else { + throw new RuntimeException(("Illegal union index for 'F893': "+ unionIndex893)); + } + } + int unionIndex894 = (decoder.readIndex()); + if (unionIndex894 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(894, null); + } else { + if (unionIndex894 == 1) { + Utf8 charSequence894; + Object oldString894 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(894); + if (oldString894 instanceof Utf8) { + charSequence894 = (decoder).readString(((Utf8) oldString894)); + } else { + charSequence894 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(894, charSequence894); + } else { + throw new RuntimeException(("Illegal union index for 'F894': "+ unionIndex894)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex895 = (decoder.readIndex()); + if (unionIndex895 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(895, null); + } else { + if (unionIndex895 == 1) { + Utf8 charSequence895; + Object oldString895 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(895); + if (oldString895 instanceof Utf8) { + charSequence895 = (decoder).readString(((Utf8) oldString895)); + } else { + charSequence895 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(895, charSequence895); + } else { + throw new RuntimeException(("Illegal union index for 'F895': "+ unionIndex895)); + } + } + int unionIndex896 = (decoder.readIndex()); + if (unionIndex896 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(896, null); + } else { + if (unionIndex896 == 1) { + Utf8 charSequence896; + Object oldString896 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(896); + if (oldString896 instanceof Utf8) { + charSequence896 = (decoder).readString(((Utf8) oldString896)); + } else { + charSequence896 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(896, charSequence896); + } else { + throw new RuntimeException(("Illegal union index for 'F896': "+ unionIndex896)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex897 = (decoder.readIndex()); + if (unionIndex897 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(897, null); + } else { + if (unionIndex897 == 1) { + Utf8 charSequence897; + Object oldString897 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(897); + if (oldString897 instanceof Utf8) { + charSequence897 = (decoder).readString(((Utf8) oldString897)); + } else { + charSequence897 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(897, charSequence897); + } else { + throw new RuntimeException(("Illegal union index for 'F897': "+ unionIndex897)); + } + } + int unionIndex898 = (decoder.readIndex()); + if (unionIndex898 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(898, null); + } else { + if (unionIndex898 == 1) { + Utf8 charSequence898; + Object oldString898 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(898); + if (oldString898 instanceof Utf8) { + charSequence898 = (decoder).readString(((Utf8) oldString898)); + } else { + charSequence898 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(898, charSequence898); + } else { + throw new RuntimeException(("Illegal union index for 'F898': "+ unionIndex898)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex899 = (decoder.readIndex()); + if (unionIndex899 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(899, null); + } else { + if (unionIndex899 == 1) { + Utf8 charSequence899; + Object oldString899 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(899); + if (oldString899 instanceof Utf8) { + charSequence899 = (decoder).readString(((Utf8) oldString899)); + } else { + charSequence899 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(899, charSequence899); + } else { + throw new RuntimeException(("Illegal union index for 'F899': "+ unionIndex899)); + } + } + int unionIndex900 = (decoder.readIndex()); + if (unionIndex900 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(900, null); + } else { + if (unionIndex900 == 1) { + Utf8 charSequence900; + Object oldString900 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(900); + if (oldString900 instanceof Utf8) { + charSequence900 = (decoder).readString(((Utf8) oldString900)); + } else { + charSequence900 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(900, charSequence900); + } else { + throw new RuntimeException(("Illegal union index for 'F900': "+ unionIndex900)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex901 = (decoder.readIndex()); + if (unionIndex901 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(901, null); + } else { + if (unionIndex901 == 1) { + Utf8 charSequence901; + Object oldString901 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(901); + if (oldString901 instanceof Utf8) { + charSequence901 = (decoder).readString(((Utf8) oldString901)); + } else { + charSequence901 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(901, charSequence901); + } else { + throw new RuntimeException(("Illegal union index for 'F901': "+ unionIndex901)); + } + } + int unionIndex902 = (decoder.readIndex()); + if (unionIndex902 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(902, null); + } else { + if (unionIndex902 == 1) { + Utf8 charSequence902; + Object oldString902 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(902); + if (oldString902 instanceof Utf8) { + charSequence902 = (decoder).readString(((Utf8) oldString902)); + } else { + charSequence902 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(902, charSequence902); + } else { + throw new RuntimeException(("Illegal union index for 'F902': "+ unionIndex902)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex903 = (decoder.readIndex()); + if (unionIndex903 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(903, null); + } else { + if (unionIndex903 == 1) { + Utf8 charSequence903; + Object oldString903 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(903); + if (oldString903 instanceof Utf8) { + charSequence903 = (decoder).readString(((Utf8) oldString903)); + } else { + charSequence903 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(903, charSequence903); + } else { + throw new RuntimeException(("Illegal union index for 'F903': "+ unionIndex903)); + } + } + int unionIndex904 = (decoder.readIndex()); + if (unionIndex904 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(904, null); + } else { + if (unionIndex904 == 1) { + Utf8 charSequence904; + Object oldString904 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(904); + if (oldString904 instanceof Utf8) { + charSequence904 = (decoder).readString(((Utf8) oldString904)); + } else { + charSequence904 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(904, charSequence904); + } else { + throw new RuntimeException(("Illegal union index for 'F904': "+ unionIndex904)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex905 = (decoder.readIndex()); + if (unionIndex905 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(905, null); + } else { + if (unionIndex905 == 1) { + Utf8 charSequence905; + Object oldString905 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(905); + if (oldString905 instanceof Utf8) { + charSequence905 = (decoder).readString(((Utf8) oldString905)); + } else { + charSequence905 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(905, charSequence905); + } else { + throw new RuntimeException(("Illegal union index for 'F905': "+ unionIndex905)); + } + } + int unionIndex906 = (decoder.readIndex()); + if (unionIndex906 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(906, null); + } else { + if (unionIndex906 == 1) { + Utf8 charSequence906; + Object oldString906 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(906); + if (oldString906 instanceof Utf8) { + charSequence906 = (decoder).readString(((Utf8) oldString906)); + } else { + charSequence906 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(906, charSequence906); + } else { + throw new RuntimeException(("Illegal union index for 'F906': "+ unionIndex906)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex907 = (decoder.readIndex()); + if (unionIndex907 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(907, null); + } else { + if (unionIndex907 == 1) { + Utf8 charSequence907; + Object oldString907 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(907); + if (oldString907 instanceof Utf8) { + charSequence907 = (decoder).readString(((Utf8) oldString907)); + } else { + charSequence907 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(907, charSequence907); + } else { + throw new RuntimeException(("Illegal union index for 'F907': "+ unionIndex907)); + } + } + int unionIndex908 = (decoder.readIndex()); + if (unionIndex908 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(908, null); + } else { + if (unionIndex908 == 1) { + Utf8 charSequence908; + Object oldString908 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(908); + if (oldString908 instanceof Utf8) { + charSequence908 = (decoder).readString(((Utf8) oldString908)); + } else { + charSequence908 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(908, charSequence908); + } else { + throw new RuntimeException(("Illegal union index for 'F908': "+ unionIndex908)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex909 = (decoder.readIndex()); + if (unionIndex909 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(909, null); + } else { + if (unionIndex909 == 1) { + Utf8 charSequence909; + Object oldString909 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(909); + if (oldString909 instanceof Utf8) { + charSequence909 = (decoder).readString(((Utf8) oldString909)); + } else { + charSequence909 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(909, charSequence909); + } else { + throw new RuntimeException(("Illegal union index for 'F909': "+ unionIndex909)); + } + } + int unionIndex910 = (decoder.readIndex()); + if (unionIndex910 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(910, null); + } else { + if (unionIndex910 == 1) { + Utf8 charSequence910; + Object oldString910 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(910); + if (oldString910 instanceof Utf8) { + charSequence910 = (decoder).readString(((Utf8) oldString910)); + } else { + charSequence910 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(910, charSequence910); + } else { + throw new RuntimeException(("Illegal union index for 'F910': "+ unionIndex910)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex911 = (decoder.readIndex()); + if (unionIndex911 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(911, null); + } else { + if (unionIndex911 == 1) { + Utf8 charSequence911; + Object oldString911 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(911); + if (oldString911 instanceof Utf8) { + charSequence911 = (decoder).readString(((Utf8) oldString911)); + } else { + charSequence911 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(911, charSequence911); + } else { + throw new RuntimeException(("Illegal union index for 'F911': "+ unionIndex911)); + } + } + int unionIndex912 = (decoder.readIndex()); + if (unionIndex912 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(912, null); + } else { + if (unionIndex912 == 1) { + Utf8 charSequence912; + Object oldString912 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(912); + if (oldString912 instanceof Utf8) { + charSequence912 = (decoder).readString(((Utf8) oldString912)); + } else { + charSequence912 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(912, charSequence912); + } else { + throw new RuntimeException(("Illegal union index for 'F912': "+ unionIndex912)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex913 = (decoder.readIndex()); + if (unionIndex913 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(913, null); + } else { + if (unionIndex913 == 1) { + Utf8 charSequence913; + Object oldString913 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(913); + if (oldString913 instanceof Utf8) { + charSequence913 = (decoder).readString(((Utf8) oldString913)); + } else { + charSequence913 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(913, charSequence913); + } else { + throw new RuntimeException(("Illegal union index for 'F913': "+ unionIndex913)); + } + } + int unionIndex914 = (decoder.readIndex()); + if (unionIndex914 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(914, null); + } else { + if (unionIndex914 == 1) { + Utf8 charSequence914; + Object oldString914 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(914); + if (oldString914 instanceof Utf8) { + charSequence914 = (decoder).readString(((Utf8) oldString914)); + } else { + charSequence914 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(914, charSequence914); + } else { + throw new RuntimeException(("Illegal union index for 'F914': "+ unionIndex914)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex915 = (decoder.readIndex()); + if (unionIndex915 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(915, null); + } else { + if (unionIndex915 == 1) { + Utf8 charSequence915; + Object oldString915 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(915); + if (oldString915 instanceof Utf8) { + charSequence915 = (decoder).readString(((Utf8) oldString915)); + } else { + charSequence915 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(915, charSequence915); + } else { + throw new RuntimeException(("Illegal union index for 'F915': "+ unionIndex915)); + } + } + int unionIndex916 = (decoder.readIndex()); + if (unionIndex916 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(916, null); + } else { + if (unionIndex916 == 1) { + Utf8 charSequence916; + Object oldString916 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(916); + if (oldString916 instanceof Utf8) { + charSequence916 = (decoder).readString(((Utf8) oldString916)); + } else { + charSequence916 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(916, charSequence916); + } else { + throw new RuntimeException(("Illegal union index for 'F916': "+ unionIndex916)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex917 = (decoder.readIndex()); + if (unionIndex917 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(917, null); + } else { + if (unionIndex917 == 1) { + Utf8 charSequence917; + Object oldString917 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(917); + if (oldString917 instanceof Utf8) { + charSequence917 = (decoder).readString(((Utf8) oldString917)); + } else { + charSequence917 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(917, charSequence917); + } else { + throw new RuntimeException(("Illegal union index for 'F917': "+ unionIndex917)); + } + } + int unionIndex918 = (decoder.readIndex()); + if (unionIndex918 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(918, null); + } else { + if (unionIndex918 == 1) { + Utf8 charSequence918; + Object oldString918 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(918); + if (oldString918 instanceof Utf8) { + charSequence918 = (decoder).readString(((Utf8) oldString918)); + } else { + charSequence918 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(918, charSequence918); + } else { + throw new RuntimeException(("Illegal union index for 'F918': "+ unionIndex918)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex919 = (decoder.readIndex()); + if (unionIndex919 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(919, null); + } else { + if (unionIndex919 == 1) { + Utf8 charSequence919; + Object oldString919 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(919); + if (oldString919 instanceof Utf8) { + charSequence919 = (decoder).readString(((Utf8) oldString919)); + } else { + charSequence919 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(919, charSequence919); + } else { + throw new RuntimeException(("Illegal union index for 'F919': "+ unionIndex919)); + } + } + int unionIndex920 = (decoder.readIndex()); + if (unionIndex920 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(920, null); + } else { + if (unionIndex920 == 1) { + Utf8 charSequence920; + Object oldString920 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(920); + if (oldString920 instanceof Utf8) { + charSequence920 = (decoder).readString(((Utf8) oldString920)); + } else { + charSequence920 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(920, charSequence920); + } else { + throw new RuntimeException(("Illegal union index for 'F920': "+ unionIndex920)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex921 = (decoder.readIndex()); + if (unionIndex921 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(921, null); + } else { + if (unionIndex921 == 1) { + Utf8 charSequence921; + Object oldString921 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(921); + if (oldString921 instanceof Utf8) { + charSequence921 = (decoder).readString(((Utf8) oldString921)); + } else { + charSequence921 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(921, charSequence921); + } else { + throw new RuntimeException(("Illegal union index for 'F921': "+ unionIndex921)); + } + } + int unionIndex922 = (decoder.readIndex()); + if (unionIndex922 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(922, null); + } else { + if (unionIndex922 == 1) { + Utf8 charSequence922; + Object oldString922 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(922); + if (oldString922 instanceof Utf8) { + charSequence922 = (decoder).readString(((Utf8) oldString922)); + } else { + charSequence922 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(922, charSequence922); + } else { + throw new RuntimeException(("Illegal union index for 'F922': "+ unionIndex922)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex923 = (decoder.readIndex()); + if (unionIndex923 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(923, null); + } else { + if (unionIndex923 == 1) { + Utf8 charSequence923; + Object oldString923 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(923); + if (oldString923 instanceof Utf8) { + charSequence923 = (decoder).readString(((Utf8) oldString923)); + } else { + charSequence923 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(923, charSequence923); + } else { + throw new RuntimeException(("Illegal union index for 'F923': "+ unionIndex923)); + } + } + int unionIndex924 = (decoder.readIndex()); + if (unionIndex924 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(924, null); + } else { + if (unionIndex924 == 1) { + Utf8 charSequence924; + Object oldString924 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(924); + if (oldString924 instanceof Utf8) { + charSequence924 = (decoder).readString(((Utf8) oldString924)); + } else { + charSequence924 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(924, charSequence924); + } else { + throw new RuntimeException(("Illegal union index for 'F924': "+ unionIndex924)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex925 = (decoder.readIndex()); + if (unionIndex925 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(925, null); + } else { + if (unionIndex925 == 1) { + Utf8 charSequence925; + Object oldString925 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(925); + if (oldString925 instanceof Utf8) { + charSequence925 = (decoder).readString(((Utf8) oldString925)); + } else { + charSequence925 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(925, charSequence925); + } else { + throw new RuntimeException(("Illegal union index for 'F925': "+ unionIndex925)); + } + } + int unionIndex926 = (decoder.readIndex()); + if (unionIndex926 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(926, null); + } else { + if (unionIndex926 == 1) { + Utf8 charSequence926; + Object oldString926 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(926); + if (oldString926 instanceof Utf8) { + charSequence926 = (decoder).readString(((Utf8) oldString926)); + } else { + charSequence926 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(926, charSequence926); + } else { + throw new RuntimeException(("Illegal union index for 'F926': "+ unionIndex926)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex927 = (decoder.readIndex()); + if (unionIndex927 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(927, null); + } else { + if (unionIndex927 == 1) { + Utf8 charSequence927; + Object oldString927 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(927); + if (oldString927 instanceof Utf8) { + charSequence927 = (decoder).readString(((Utf8) oldString927)); + } else { + charSequence927 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(927, charSequence927); + } else { + throw new RuntimeException(("Illegal union index for 'F927': "+ unionIndex927)); + } + } + int unionIndex928 = (decoder.readIndex()); + if (unionIndex928 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(928, null); + } else { + if (unionIndex928 == 1) { + Utf8 charSequence928; + Object oldString928 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(928); + if (oldString928 instanceof Utf8) { + charSequence928 = (decoder).readString(((Utf8) oldString928)); + } else { + charSequence928 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(928, charSequence928); + } else { + throw new RuntimeException(("Illegal union index for 'F928': "+ unionIndex928)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex929 = (decoder.readIndex()); + if (unionIndex929 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(929, null); + } else { + if (unionIndex929 == 1) { + Utf8 charSequence929; + Object oldString929 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(929); + if (oldString929 instanceof Utf8) { + charSequence929 = (decoder).readString(((Utf8) oldString929)); + } else { + charSequence929 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(929, charSequence929); + } else { + throw new RuntimeException(("Illegal union index for 'F929': "+ unionIndex929)); + } + } + int unionIndex930 = (decoder.readIndex()); + if (unionIndex930 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(930, null); + } else { + if (unionIndex930 == 1) { + Utf8 charSequence930; + Object oldString930 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(930); + if (oldString930 instanceof Utf8) { + charSequence930 = (decoder).readString(((Utf8) oldString930)); + } else { + charSequence930 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(930, charSequence930); + } else { + throw new RuntimeException(("Illegal union index for 'F930': "+ unionIndex930)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex931 = (decoder.readIndex()); + if (unionIndex931 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(931, null); + } else { + if (unionIndex931 == 1) { + Utf8 charSequence931; + Object oldString931 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(931); + if (oldString931 instanceof Utf8) { + charSequence931 = (decoder).readString(((Utf8) oldString931)); + } else { + charSequence931 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(931, charSequence931); + } else { + throw new RuntimeException(("Illegal union index for 'F931': "+ unionIndex931)); + } + } + int unionIndex932 = (decoder.readIndex()); + if (unionIndex932 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(932, null); + } else { + if (unionIndex932 == 1) { + Utf8 charSequence932; + Object oldString932 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(932); + if (oldString932 instanceof Utf8) { + charSequence932 = (decoder).readString(((Utf8) oldString932)); + } else { + charSequence932 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(932, charSequence932); + } else { + throw new RuntimeException(("Illegal union index for 'F932': "+ unionIndex932)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex933 = (decoder.readIndex()); + if (unionIndex933 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(933, null); + } else { + if (unionIndex933 == 1) { + Utf8 charSequence933; + Object oldString933 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(933); + if (oldString933 instanceof Utf8) { + charSequence933 = (decoder).readString(((Utf8) oldString933)); + } else { + charSequence933 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(933, charSequence933); + } else { + throw new RuntimeException(("Illegal union index for 'F933': "+ unionIndex933)); + } + } + int unionIndex934 = (decoder.readIndex()); + if (unionIndex934 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(934, null); + } else { + if (unionIndex934 == 1) { + Utf8 charSequence934; + Object oldString934 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(934); + if (oldString934 instanceof Utf8) { + charSequence934 = (decoder).readString(((Utf8) oldString934)); + } else { + charSequence934 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(934, charSequence934); + } else { + throw new RuntimeException(("Illegal union index for 'F934': "+ unionIndex934)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex935 = (decoder.readIndex()); + if (unionIndex935 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(935, null); + } else { + if (unionIndex935 == 1) { + Utf8 charSequence935; + Object oldString935 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(935); + if (oldString935 instanceof Utf8) { + charSequence935 = (decoder).readString(((Utf8) oldString935)); + } else { + charSequence935 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(935, charSequence935); + } else { + throw new RuntimeException(("Illegal union index for 'F935': "+ unionIndex935)); + } + } + int unionIndex936 = (decoder.readIndex()); + if (unionIndex936 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(936, null); + } else { + if (unionIndex936 == 1) { + Utf8 charSequence936; + Object oldString936 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(936); + if (oldString936 instanceof Utf8) { + charSequence936 = (decoder).readString(((Utf8) oldString936)); + } else { + charSequence936 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(936, charSequence936); + } else { + throw new RuntimeException(("Illegal union index for 'F936': "+ unionIndex936)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex937 = (decoder.readIndex()); + if (unionIndex937 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(937, null); + } else { + if (unionIndex937 == 1) { + Utf8 charSequence937; + Object oldString937 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(937); + if (oldString937 instanceof Utf8) { + charSequence937 = (decoder).readString(((Utf8) oldString937)); + } else { + charSequence937 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(937, charSequence937); + } else { + throw new RuntimeException(("Illegal union index for 'F937': "+ unionIndex937)); + } + } + int unionIndex938 = (decoder.readIndex()); + if (unionIndex938 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(938, null); + } else { + if (unionIndex938 == 1) { + Utf8 charSequence938; + Object oldString938 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(938); + if (oldString938 instanceof Utf8) { + charSequence938 = (decoder).readString(((Utf8) oldString938)); + } else { + charSequence938 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(938, charSequence938); + } else { + throw new RuntimeException(("Illegal union index for 'F938': "+ unionIndex938)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex939 = (decoder.readIndex()); + if (unionIndex939 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(939, null); + } else { + if (unionIndex939 == 1) { + Utf8 charSequence939; + Object oldString939 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(939); + if (oldString939 instanceof Utf8) { + charSequence939 = (decoder).readString(((Utf8) oldString939)); + } else { + charSequence939 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(939, charSequence939); + } else { + throw new RuntimeException(("Illegal union index for 'F939': "+ unionIndex939)); + } + } + int unionIndex940 = (decoder.readIndex()); + if (unionIndex940 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(940, null); + } else { + if (unionIndex940 == 1) { + Utf8 charSequence940; + Object oldString940 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(940); + if (oldString940 instanceof Utf8) { + charSequence940 = (decoder).readString(((Utf8) oldString940)); + } else { + charSequence940 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(940, charSequence940); + } else { + throw new RuntimeException(("Illegal union index for 'F940': "+ unionIndex940)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex941 = (decoder.readIndex()); + if (unionIndex941 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(941, null); + } else { + if (unionIndex941 == 1) { + Utf8 charSequence941; + Object oldString941 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(941); + if (oldString941 instanceof Utf8) { + charSequence941 = (decoder).readString(((Utf8) oldString941)); + } else { + charSequence941 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(941, charSequence941); + } else { + throw new RuntimeException(("Illegal union index for 'F941': "+ unionIndex941)); + } + } + int unionIndex942 = (decoder.readIndex()); + if (unionIndex942 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(942, null); + } else { + if (unionIndex942 == 1) { + Utf8 charSequence942; + Object oldString942 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(942); + if (oldString942 instanceof Utf8) { + charSequence942 = (decoder).readString(((Utf8) oldString942)); + } else { + charSequence942 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(942, charSequence942); + } else { + throw new RuntimeException(("Illegal union index for 'F942': "+ unionIndex942)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex943 = (decoder.readIndex()); + if (unionIndex943 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(943, null); + } else { + if (unionIndex943 == 1) { + Utf8 charSequence943; + Object oldString943 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(943); + if (oldString943 instanceof Utf8) { + charSequence943 = (decoder).readString(((Utf8) oldString943)); + } else { + charSequence943 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(943, charSequence943); + } else { + throw new RuntimeException(("Illegal union index for 'F943': "+ unionIndex943)); + } + } + int unionIndex944 = (decoder.readIndex()); + if (unionIndex944 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(944, null); + } else { + if (unionIndex944 == 1) { + Utf8 charSequence944; + Object oldString944 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(944); + if (oldString944 instanceof Utf8) { + charSequence944 = (decoder).readString(((Utf8) oldString944)); + } else { + charSequence944 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(944, charSequence944); + } else { + throw new RuntimeException(("Illegal union index for 'F944': "+ unionIndex944)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex945 = (decoder.readIndex()); + if (unionIndex945 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(945, null); + } else { + if (unionIndex945 == 1) { + Utf8 charSequence945; + Object oldString945 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(945); + if (oldString945 instanceof Utf8) { + charSequence945 = (decoder).readString(((Utf8) oldString945)); + } else { + charSequence945 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(945, charSequence945); + } else { + throw new RuntimeException(("Illegal union index for 'F945': "+ unionIndex945)); + } + } + int unionIndex946 = (decoder.readIndex()); + if (unionIndex946 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(946, null); + } else { + if (unionIndex946 == 1) { + Utf8 charSequence946; + Object oldString946 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(946); + if (oldString946 instanceof Utf8) { + charSequence946 = (decoder).readString(((Utf8) oldString946)); + } else { + charSequence946 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(946, charSequence946); + } else { + throw new RuntimeException(("Illegal union index for 'F946': "+ unionIndex946)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex947 = (decoder.readIndex()); + if (unionIndex947 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(947, null); + } else { + if (unionIndex947 == 1) { + Utf8 charSequence947; + Object oldString947 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(947); + if (oldString947 instanceof Utf8) { + charSequence947 = (decoder).readString(((Utf8) oldString947)); + } else { + charSequence947 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(947, charSequence947); + } else { + throw new RuntimeException(("Illegal union index for 'F947': "+ unionIndex947)); + } + } + int unionIndex948 = (decoder.readIndex()); + if (unionIndex948 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(948, null); + } else { + if (unionIndex948 == 1) { + Utf8 charSequence948; + Object oldString948 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(948); + if (oldString948 instanceof Utf8) { + charSequence948 = (decoder).readString(((Utf8) oldString948)); + } else { + charSequence948 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(948, charSequence948); + } else { + throw new RuntimeException(("Illegal union index for 'F948': "+ unionIndex948)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex949 = (decoder.readIndex()); + if (unionIndex949 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(949, null); + } else { + if (unionIndex949 == 1) { + Utf8 charSequence949; + Object oldString949 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(949); + if (oldString949 instanceof Utf8) { + charSequence949 = (decoder).readString(((Utf8) oldString949)); + } else { + charSequence949 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(949, charSequence949); + } else { + throw new RuntimeException(("Illegal union index for 'F949': "+ unionIndex949)); + } + } + int unionIndex950 = (decoder.readIndex()); + if (unionIndex950 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(950, null); + } else { + if (unionIndex950 == 1) { + Utf8 charSequence950; + Object oldString950 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(950); + if (oldString950 instanceof Utf8) { + charSequence950 = (decoder).readString(((Utf8) oldString950)); + } else { + charSequence950 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(950, charSequence950); + } else { + throw new RuntimeException(("Illegal union index for 'F950': "+ unionIndex950)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex951 = (decoder.readIndex()); + if (unionIndex951 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(951, null); + } else { + if (unionIndex951 == 1) { + Utf8 charSequence951; + Object oldString951 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(951); + if (oldString951 instanceof Utf8) { + charSequence951 = (decoder).readString(((Utf8) oldString951)); + } else { + charSequence951 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(951, charSequence951); + } else { + throw new RuntimeException(("Illegal union index for 'F951': "+ unionIndex951)); + } + } + int unionIndex952 = (decoder.readIndex()); + if (unionIndex952 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(952, null); + } else { + if (unionIndex952 == 1) { + Utf8 charSequence952; + Object oldString952 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(952); + if (oldString952 instanceof Utf8) { + charSequence952 = (decoder).readString(((Utf8) oldString952)); + } else { + charSequence952 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(952, charSequence952); + } else { + throw new RuntimeException(("Illegal union index for 'F952': "+ unionIndex952)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex953 = (decoder.readIndex()); + if (unionIndex953 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(953, null); + } else { + if (unionIndex953 == 1) { + Utf8 charSequence953; + Object oldString953 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(953); + if (oldString953 instanceof Utf8) { + charSequence953 = (decoder).readString(((Utf8) oldString953)); + } else { + charSequence953 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(953, charSequence953); + } else { + throw new RuntimeException(("Illegal union index for 'F953': "+ unionIndex953)); + } + } + int unionIndex954 = (decoder.readIndex()); + if (unionIndex954 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(954, null); + } else { + if (unionIndex954 == 1) { + Utf8 charSequence954; + Object oldString954 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(954); + if (oldString954 instanceof Utf8) { + charSequence954 = (decoder).readString(((Utf8) oldString954)); + } else { + charSequence954 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(954, charSequence954); + } else { + throw new RuntimeException(("Illegal union index for 'F954': "+ unionIndex954)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex955 = (decoder.readIndex()); + if (unionIndex955 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(955, null); + } else { + if (unionIndex955 == 1) { + Utf8 charSequence955; + Object oldString955 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(955); + if (oldString955 instanceof Utf8) { + charSequence955 = (decoder).readString(((Utf8) oldString955)); + } else { + charSequence955 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(955, charSequence955); + } else { + throw new RuntimeException(("Illegal union index for 'F955': "+ unionIndex955)); + } + } + int unionIndex956 = (decoder.readIndex()); + if (unionIndex956 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(956, null); + } else { + if (unionIndex956 == 1) { + Utf8 charSequence956; + Object oldString956 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(956); + if (oldString956 instanceof Utf8) { + charSequence956 = (decoder).readString(((Utf8) oldString956)); + } else { + charSequence956 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(956, charSequence956); + } else { + throw new RuntimeException(("Illegal union index for 'F956': "+ unionIndex956)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex957 = (decoder.readIndex()); + if (unionIndex957 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(957, null); + } else { + if (unionIndex957 == 1) { + Utf8 charSequence957; + Object oldString957 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(957); + if (oldString957 instanceof Utf8) { + charSequence957 = (decoder).readString(((Utf8) oldString957)); + } else { + charSequence957 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(957, charSequence957); + } else { + throw new RuntimeException(("Illegal union index for 'F957': "+ unionIndex957)); + } + } + int unionIndex958 = (decoder.readIndex()); + if (unionIndex958 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(958, null); + } else { + if (unionIndex958 == 1) { + Utf8 charSequence958; + Object oldString958 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(958); + if (oldString958 instanceof Utf8) { + charSequence958 = (decoder).readString(((Utf8) oldString958)); + } else { + charSequence958 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(958, charSequence958); + } else { + throw new RuntimeException(("Illegal union index for 'F958': "+ unionIndex958)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex959 = (decoder.readIndex()); + if (unionIndex959 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(959, null); + } else { + if (unionIndex959 == 1) { + Utf8 charSequence959; + Object oldString959 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(959); + if (oldString959 instanceof Utf8) { + charSequence959 = (decoder).readString(((Utf8) oldString959)); + } else { + charSequence959 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(959, charSequence959); + } else { + throw new RuntimeException(("Illegal union index for 'F959': "+ unionIndex959)); + } + } + int unionIndex960 = (decoder.readIndex()); + if (unionIndex960 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(960, null); + } else { + if (unionIndex960 == 1) { + Utf8 charSequence960; + Object oldString960 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(960); + if (oldString960 instanceof Utf8) { + charSequence960 = (decoder).readString(((Utf8) oldString960)); + } else { + charSequence960 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(960, charSequence960); + } else { + throw new RuntimeException(("Illegal union index for 'F960': "+ unionIndex960)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex961 = (decoder.readIndex()); + if (unionIndex961 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(961, null); + } else { + if (unionIndex961 == 1) { + Utf8 charSequence961; + Object oldString961 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(961); + if (oldString961 instanceof Utf8) { + charSequence961 = (decoder).readString(((Utf8) oldString961)); + } else { + charSequence961 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(961, charSequence961); + } else { + throw new RuntimeException(("Illegal union index for 'F961': "+ unionIndex961)); + } + } + int unionIndex962 = (decoder.readIndex()); + if (unionIndex962 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(962, null); + } else { + if (unionIndex962 == 1) { + Utf8 charSequence962; + Object oldString962 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(962); + if (oldString962 instanceof Utf8) { + charSequence962 = (decoder).readString(((Utf8) oldString962)); + } else { + charSequence962 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(962, charSequence962); + } else { + throw new RuntimeException(("Illegal union index for 'F962': "+ unionIndex962)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex963 = (decoder.readIndex()); + if (unionIndex963 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(963, null); + } else { + if (unionIndex963 == 1) { + Utf8 charSequence963; + Object oldString963 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(963); + if (oldString963 instanceof Utf8) { + charSequence963 = (decoder).readString(((Utf8) oldString963)); + } else { + charSequence963 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(963, charSequence963); + } else { + throw new RuntimeException(("Illegal union index for 'F963': "+ unionIndex963)); + } + } + int unionIndex964 = (decoder.readIndex()); + if (unionIndex964 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(964, null); + } else { + if (unionIndex964 == 1) { + Utf8 charSequence964; + Object oldString964 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(964); + if (oldString964 instanceof Utf8) { + charSequence964 = (decoder).readString(((Utf8) oldString964)); + } else { + charSequence964 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(964, charSequence964); + } else { + throw new RuntimeException(("Illegal union index for 'F964': "+ unionIndex964)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex965 = (decoder.readIndex()); + if (unionIndex965 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(965, null); + } else { + if (unionIndex965 == 1) { + Utf8 charSequence965; + Object oldString965 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(965); + if (oldString965 instanceof Utf8) { + charSequence965 = (decoder).readString(((Utf8) oldString965)); + } else { + charSequence965 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(965, charSequence965); + } else { + throw new RuntimeException(("Illegal union index for 'F965': "+ unionIndex965)); + } + } + int unionIndex966 = (decoder.readIndex()); + if (unionIndex966 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(966, null); + } else { + if (unionIndex966 == 1) { + Utf8 charSequence966; + Object oldString966 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(966); + if (oldString966 instanceof Utf8) { + charSequence966 = (decoder).readString(((Utf8) oldString966)); + } else { + charSequence966 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(966, charSequence966); + } else { + throw new RuntimeException(("Illegal union index for 'F966': "+ unionIndex966)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex967 = (decoder.readIndex()); + if (unionIndex967 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(967, null); + } else { + if (unionIndex967 == 1) { + Utf8 charSequence967; + Object oldString967 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(967); + if (oldString967 instanceof Utf8) { + charSequence967 = (decoder).readString(((Utf8) oldString967)); + } else { + charSequence967 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(967, charSequence967); + } else { + throw new RuntimeException(("Illegal union index for 'F967': "+ unionIndex967)); + } + } + int unionIndex968 = (decoder.readIndex()); + if (unionIndex968 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(968, null); + } else { + if (unionIndex968 == 1) { + Utf8 charSequence968; + Object oldString968 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(968); + if (oldString968 instanceof Utf8) { + charSequence968 = (decoder).readString(((Utf8) oldString968)); + } else { + charSequence968 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(968, charSequence968); + } else { + throw new RuntimeException(("Illegal union index for 'F968': "+ unionIndex968)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex969 = (decoder.readIndex()); + if (unionIndex969 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(969, null); + } else { + if (unionIndex969 == 1) { + Utf8 charSequence969; + Object oldString969 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(969); + if (oldString969 instanceof Utf8) { + charSequence969 = (decoder).readString(((Utf8) oldString969)); + } else { + charSequence969 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(969, charSequence969); + } else { + throw new RuntimeException(("Illegal union index for 'F969': "+ unionIndex969)); + } + } + int unionIndex970 = (decoder.readIndex()); + if (unionIndex970 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(970, null); + } else { + if (unionIndex970 == 1) { + Utf8 charSequence970; + Object oldString970 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(970); + if (oldString970 instanceof Utf8) { + charSequence970 = (decoder).readString(((Utf8) oldString970)); + } else { + charSequence970 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(970, charSequence970); + } else { + throw new RuntimeException(("Illegal union index for 'F970': "+ unionIndex970)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex971 = (decoder.readIndex()); + if (unionIndex971 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(971, null); + } else { + if (unionIndex971 == 1) { + Utf8 charSequence971; + Object oldString971 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(971); + if (oldString971 instanceof Utf8) { + charSequence971 = (decoder).readString(((Utf8) oldString971)); + } else { + charSequence971 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(971, charSequence971); + } else { + throw new RuntimeException(("Illegal union index for 'F971': "+ unionIndex971)); + } + } + int unionIndex972 = (decoder.readIndex()); + if (unionIndex972 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(972, null); + } else { + if (unionIndex972 == 1) { + Utf8 charSequence972; + Object oldString972 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(972); + if (oldString972 instanceof Utf8) { + charSequence972 = (decoder).readString(((Utf8) oldString972)); + } else { + charSequence972 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(972, charSequence972); + } else { + throw new RuntimeException(("Illegal union index for 'F972': "+ unionIndex972)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex973 = (decoder.readIndex()); + if (unionIndex973 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(973, null); + } else { + if (unionIndex973 == 1) { + Utf8 charSequence973; + Object oldString973 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(973); + if (oldString973 instanceof Utf8) { + charSequence973 = (decoder).readString(((Utf8) oldString973)); + } else { + charSequence973 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(973, charSequence973); + } else { + throw new RuntimeException(("Illegal union index for 'F973': "+ unionIndex973)); + } + } + int unionIndex974 = (decoder.readIndex()); + if (unionIndex974 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(974, null); + } else { + if (unionIndex974 == 1) { + Utf8 charSequence974; + Object oldString974 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(974); + if (oldString974 instanceof Utf8) { + charSequence974 = (decoder).readString(((Utf8) oldString974)); + } else { + charSequence974 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(974, charSequence974); + } else { + throw new RuntimeException(("Illegal union index for 'F974': "+ unionIndex974)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex975 = (decoder.readIndex()); + if (unionIndex975 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(975, null); + } else { + if (unionIndex975 == 1) { + Utf8 charSequence975; + Object oldString975 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(975); + if (oldString975 instanceof Utf8) { + charSequence975 = (decoder).readString(((Utf8) oldString975)); + } else { + charSequence975 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(975, charSequence975); + } else { + throw new RuntimeException(("Illegal union index for 'F975': "+ unionIndex975)); + } + } + int unionIndex976 = (decoder.readIndex()); + if (unionIndex976 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(976, null); + } else { + if (unionIndex976 == 1) { + Utf8 charSequence976; + Object oldString976 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(976); + if (oldString976 instanceof Utf8) { + charSequence976 = (decoder).readString(((Utf8) oldString976)); + } else { + charSequence976 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(976, charSequence976); + } else { + throw new RuntimeException(("Illegal union index for 'F976': "+ unionIndex976)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex977 = (decoder.readIndex()); + if (unionIndex977 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(977, null); + } else { + if (unionIndex977 == 1) { + Utf8 charSequence977; + Object oldString977 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(977); + if (oldString977 instanceof Utf8) { + charSequence977 = (decoder).readString(((Utf8) oldString977)); + } else { + charSequence977 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(977, charSequence977); + } else { + throw new RuntimeException(("Illegal union index for 'F977': "+ unionIndex977)); + } + } + int unionIndex978 = (decoder.readIndex()); + if (unionIndex978 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(978, null); + } else { + if (unionIndex978 == 1) { + Utf8 charSequence978; + Object oldString978 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(978); + if (oldString978 instanceof Utf8) { + charSequence978 = (decoder).readString(((Utf8) oldString978)); + } else { + charSequence978 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(978, charSequence978); + } else { + throw new RuntimeException(("Illegal union index for 'F978': "+ unionIndex978)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex979 = (decoder.readIndex()); + if (unionIndex979 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(979, null); + } else { + if (unionIndex979 == 1) { + Utf8 charSequence979; + Object oldString979 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(979); + if (oldString979 instanceof Utf8) { + charSequence979 = (decoder).readString(((Utf8) oldString979)); + } else { + charSequence979 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(979, charSequence979); + } else { + throw new RuntimeException(("Illegal union index for 'F979': "+ unionIndex979)); + } + } + int unionIndex980 = (decoder.readIndex()); + if (unionIndex980 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(980, null); + } else { + if (unionIndex980 == 1) { + Utf8 charSequence980; + Object oldString980 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(980); + if (oldString980 instanceof Utf8) { + charSequence980 = (decoder).readString(((Utf8) oldString980)); + } else { + charSequence980 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(980, charSequence980); + } else { + throw new RuntimeException(("Illegal union index for 'F980': "+ unionIndex980)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex981 = (decoder.readIndex()); + if (unionIndex981 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(981, null); + } else { + if (unionIndex981 == 1) { + Utf8 charSequence981; + Object oldString981 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(981); + if (oldString981 instanceof Utf8) { + charSequence981 = (decoder).readString(((Utf8) oldString981)); + } else { + charSequence981 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(981, charSequence981); + } else { + throw new RuntimeException(("Illegal union index for 'F981': "+ unionIndex981)); + } + } + int unionIndex982 = (decoder.readIndex()); + if (unionIndex982 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(982, null); + } else { + if (unionIndex982 == 1) { + Utf8 charSequence982; + Object oldString982 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(982); + if (oldString982 instanceof Utf8) { + charSequence982 = (decoder).readString(((Utf8) oldString982)); + } else { + charSequence982 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(982, charSequence982); + } else { + throw new RuntimeException(("Illegal union index for 'F982': "+ unionIndex982)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex983 = (decoder.readIndex()); + if (unionIndex983 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(983, null); + } else { + if (unionIndex983 == 1) { + Utf8 charSequence983; + Object oldString983 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(983); + if (oldString983 instanceof Utf8) { + charSequence983 = (decoder).readString(((Utf8) oldString983)); + } else { + charSequence983 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(983, charSequence983); + } else { + throw new RuntimeException(("Illegal union index for 'F983': "+ unionIndex983)); + } + } + int unionIndex984 = (decoder.readIndex()); + if (unionIndex984 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(984, null); + } else { + if (unionIndex984 == 1) { + Utf8 charSequence984; + Object oldString984 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(984); + if (oldString984 instanceof Utf8) { + charSequence984 = (decoder).readString(((Utf8) oldString984)); + } else { + charSequence984 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(984, charSequence984); + } else { + throw new RuntimeException(("Illegal union index for 'F984': "+ unionIndex984)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex985 = (decoder.readIndex()); + if (unionIndex985 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(985, null); + } else { + if (unionIndex985 == 1) { + Utf8 charSequence985; + Object oldString985 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(985); + if (oldString985 instanceof Utf8) { + charSequence985 = (decoder).readString(((Utf8) oldString985)); + } else { + charSequence985 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(985, charSequence985); + } else { + throw new RuntimeException(("Illegal union index for 'F985': "+ unionIndex985)); + } + } + int unionIndex986 = (decoder.readIndex()); + if (unionIndex986 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(986, null); + } else { + if (unionIndex986 == 1) { + Utf8 charSequence986; + Object oldString986 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(986); + if (oldString986 instanceof Utf8) { + charSequence986 = (decoder).readString(((Utf8) oldString986)); + } else { + charSequence986 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(986, charSequence986); + } else { + throw new RuntimeException(("Illegal union index for 'F986': "+ unionIndex986)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex987 = (decoder.readIndex()); + if (unionIndex987 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(987, null); + } else { + if (unionIndex987 == 1) { + Utf8 charSequence987; + Object oldString987 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(987); + if (oldString987 instanceof Utf8) { + charSequence987 = (decoder).readString(((Utf8) oldString987)); + } else { + charSequence987 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(987, charSequence987); + } else { + throw new RuntimeException(("Illegal union index for 'F987': "+ unionIndex987)); + } + } + int unionIndex988 = (decoder.readIndex()); + if (unionIndex988 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(988, null); + } else { + if (unionIndex988 == 1) { + Utf8 charSequence988; + Object oldString988 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(988); + if (oldString988 instanceof Utf8) { + charSequence988 = (decoder).readString(((Utf8) oldString988)); + } else { + charSequence988 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(988, charSequence988); + } else { + throw new RuntimeException(("Illegal union index for 'F988': "+ unionIndex988)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex989 = (decoder.readIndex()); + if (unionIndex989 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(989, null); + } else { + if (unionIndex989 == 1) { + Utf8 charSequence989; + Object oldString989 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(989); + if (oldString989 instanceof Utf8) { + charSequence989 = (decoder).readString(((Utf8) oldString989)); + } else { + charSequence989 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(989, charSequence989); + } else { + throw new RuntimeException(("Illegal union index for 'F989': "+ unionIndex989)); + } + } + int unionIndex990 = (decoder.readIndex()); + if (unionIndex990 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(990, null); + } else { + if (unionIndex990 == 1) { + Utf8 charSequence990; + Object oldString990 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(990); + if (oldString990 instanceof Utf8) { + charSequence990 = (decoder).readString(((Utf8) oldString990)); + } else { + charSequence990 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(990, charSequence990); + } else { + throw new RuntimeException(("Illegal union index for 'F990': "+ unionIndex990)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex991 = (decoder.readIndex()); + if (unionIndex991 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(991, null); + } else { + if (unionIndex991 == 1) { + Utf8 charSequence991; + Object oldString991 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(991); + if (oldString991 instanceof Utf8) { + charSequence991 = (decoder).readString(((Utf8) oldString991)); + } else { + charSequence991 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(991, charSequence991); + } else { + throw new RuntimeException(("Illegal union index for 'F991': "+ unionIndex991)); + } + } + int unionIndex992 = (decoder.readIndex()); + if (unionIndex992 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(992, null); + } else { + if (unionIndex992 == 1) { + Utf8 charSequence992; + Object oldString992 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(992); + if (oldString992 instanceof Utf8) { + charSequence992 = (decoder).readString(((Utf8) oldString992)); + } else { + charSequence992 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(992, charSequence992); + } else { + throw new RuntimeException(("Illegal union index for 'F992': "+ unionIndex992)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex993 = (decoder.readIndex()); + if (unionIndex993 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(993, null); + } else { + if (unionIndex993 == 1) { + Utf8 charSequence993; + Object oldString993 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(993); + if (oldString993 instanceof Utf8) { + charSequence993 = (decoder).readString(((Utf8) oldString993)); + } else { + charSequence993 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(993, charSequence993); + } else { + throw new RuntimeException(("Illegal union index for 'F993': "+ unionIndex993)); + } + } + int unionIndex994 = (decoder.readIndex()); + if (unionIndex994 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(994, null); + } else { + if (unionIndex994 == 1) { + Utf8 charSequence994; + Object oldString994 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(994); + if (oldString994 instanceof Utf8) { + charSequence994 = (decoder).readString(((Utf8) oldString994)); + } else { + charSequence994 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(994, charSequence994); + } else { + throw new RuntimeException(("Illegal union index for 'F994': "+ unionIndex994)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex995 = (decoder.readIndex()); + if (unionIndex995 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(995, null); + } else { + if (unionIndex995 == 1) { + Utf8 charSequence995; + Object oldString995 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(995); + if (oldString995 instanceof Utf8) { + charSequence995 = (decoder).readString(((Utf8) oldString995)); + } else { + charSequence995 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(995, charSequence995); + } else { + throw new RuntimeException(("Illegal union index for 'F995': "+ unionIndex995)); + } + } + int unionIndex996 = (decoder.readIndex()); + if (unionIndex996 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(996, null); + } else { + if (unionIndex996 == 1) { + Utf8 charSequence996; + Object oldString996 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(996); + if (oldString996 instanceof Utf8) { + charSequence996 = (decoder).readString(((Utf8) oldString996)); + } else { + charSequence996 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(996, charSequence996); + } else { + throw new RuntimeException(("Illegal union index for 'F996': "+ unionIndex996)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex997 = (decoder.readIndex()); + if (unionIndex997 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(997, null); + } else { + if (unionIndex997 == 1) { + Utf8 charSequence997; + Object oldString997 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(997); + if (oldString997 instanceof Utf8) { + charSequence997 = (decoder).readString(((Utf8) oldString997)); + } else { + charSequence997 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(997, charSequence997); + } else { + throw new RuntimeException(("Illegal union index for 'F997': "+ unionIndex997)); + } + } + int unionIndex998 = (decoder.readIndex()); + if (unionIndex998 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(998, null); + } else { + if (unionIndex998 == 1) { + Utf8 charSequence998; + Object oldString998 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(998); + if (oldString998 instanceof Utf8) { + charSequence998 = (decoder).readString(((Utf8) oldString998)); + } else { + charSequence998 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(998, charSequence998); + } else { + throw new RuntimeException(("Illegal union index for 'F998': "+ unionIndex998)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex999 = (decoder.readIndex()); + if (unionIndex999 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(999, null); + } else { + if (unionIndex999 == 1) { + Utf8 charSequence999; + Object oldString999 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(999); + if (oldString999 instanceof Utf8) { + charSequence999 = (decoder).readString(((Utf8) oldString999)); + } else { + charSequence999 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(999, charSequence999); + } else { + throw new RuntimeException(("Illegal union index for 'F999': "+ unionIndex999)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java new file mode 100644 index 000000000..0a4a4a976 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testString0; + private final Schema testStringUnionAlias0; + + public FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testString0 = readerSchema.getField("testString").schema(); + this.testStringUnionAlias0 = readerSchema.getField("testStringUnionAlias").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadAliasedField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadAliasedField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadAliasedField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadAliasedField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadAliasedField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldReadAliasedField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'testString': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0((FastGenericDeserializerGeneratorTest_shouldReadAliasedField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadAliasedField; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadAliasedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(1, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadAliasedField.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnionAlias': "+ unionIndex1)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadEnumDefault_GenericDeserializer_693116719_1739184158.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadEnumDefault_GenericDeserializer_693116719_1739184158.java new file mode 100644 index 000000000..f4cfb3524 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadEnumDefault_GenericDeserializer_693116719_1739184158.java @@ -0,0 +1,206 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldReadEnumDefault_GenericDeserializer_693116719_1739184158 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + private final Schema testEnumUnion0; + private final Map enumMappingtestEnum1; + private final Schema testEnumArray0; + private final Map enumMappingtestEnum2; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + private final Map enumMappingtestEnum3; + + public FastGenericDeserializerGeneratorTest_shouldReadEnumDefault_GenericDeserializer_693116719_1739184158(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(3); + tempEnumMapping0 .put(new Integer(0), new Integer(0)); + tempEnumMapping0 .put(new Integer(1), new Integer(1)); + tempEnumMapping0 .put(new Integer(2), new Integer(0)); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + HashMap tempEnumMapping1 = new HashMap(3); + tempEnumMapping1 .put(new Integer(0), new Integer(0)); + tempEnumMapping1 .put(new Integer(1), new Integer(1)); + tempEnumMapping1 .put(new Integer(2), new Integer(0)); + this.enumMappingtestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + HashMap tempEnumMapping2 = new HashMap(3); + tempEnumMapping2 .put(new Integer(0), new Integer(0)); + tempEnumMapping2 .put(new Integer(1), new Integer(1)); + tempEnumMapping2 .put(new Integer(2), new Integer(0)); + this.enumMappingtestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + HashMap tempEnumMapping3 = new HashMap(3); + tempEnumMapping3 .put(new Integer(0), new Integer(0)); + tempEnumMapping3 .put(new Integer(1), new Integer(1)); + tempEnumMapping3 .put(new Integer(2), new Integer(0)); + this.enumMappingtestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadEnumDefault0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadEnumDefault0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnumDefault; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadEnumDefault = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadEnumDefault = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadEnumDefault.put(0, enumValue0); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnumDefault0((FastGenericDeserializerGeneratorTest_shouldReadEnumDefault), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnumDefault1((FastGenericDeserializerGeneratorTest_shouldReadEnumDefault), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadEnumDefault; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnumDefault0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnumDefault, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadEnumDefault.put(1, null); + } else { + if (unionIndex0 == 1) { + int enumIndex1 = (decoder.readEnum()); + GenericEnumSymbol enumValue1 = null; + Object enumIndexLookupResult1 = enumMappingtestEnum1 .get(enumIndex1); + if (enumIndexLookupResult1 instanceof Integer) { + enumValue1 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult1))); + } else { + if (enumIndexLookupResult1 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult1); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadEnumDefault.put(1, enumValue1); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadEnumDefault.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + if (testEnumArray1 instanceof GenericArray) { + ((GenericArray) testEnumArray1).reset(); + } else { + testEnumArray1 .clear(); + } + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadEnumDefault.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + if (testEnumUnionArray1 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray1).reset(); + } else { + testEnumUnionArray1 .clear(); + } + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Schema testEnumUnion0; + private final Schema testEnumArray0; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadEnum = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadEnum = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(0, new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get((decoder.readEnum())))); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum1((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(1, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(1, new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get((decoder.readEnum())))); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadEnum.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + if (testEnumArray1 instanceof GenericArray) { + ((GenericArray) testEnumArray1).reset(); + } else { + testEnumArray1 .clear(); + } + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadEnum.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + if (testEnumUnionArray1 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray1).reset(); + } else { + testEnumUnionArray1 .clear(); + } + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testFixed0; + private final Schema testFixedUnion0; + private final Schema testFixedArray0; + private final Schema testFixedUnionArray0; + private final Schema testFixedUnionArrayArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadFixed_GenericDeserializer_1590965143_1590965143(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testFixed0 = readerSchema.getField("testFixed").schema(); + this.testFixedUnion0 = readerSchema.getField("testFixedUnion").schema(); + this.testFixedArray0 = readerSchema.getField("testFixedArray").schema(); + this.testFixedUnionArray0 = readerSchema.getField("testFixedUnionArray").schema(); + this.testFixedUnionArrayArrayElemSchema0 = testFixedUnionArray0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadFixed = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadFixed = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + byte[] testFixed1; + Object oldFixed0 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(0); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (2))) { + testFixed1 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed1 = ( new byte[2]); + } + decoder.readFixed(testFixed1); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(0, new org.apache.avro.generic.GenericData.Fixed(testFixed0, testFixed1)); + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed1((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadFixed; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(1, null); + } else { + if (unionIndex0 == 1) { + byte[] testFixed2; + Object oldFixed1 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(1); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (2))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[2]); + } + decoder.readFixed(testFixed2); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(1, new org.apache.avro.generic.GenericData.Fixed(testFixed0, testFixed2)); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex0)); + } + } + List testFixedArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(2); + if (oldArray0 instanceof List) { + testFixedArray1 = ((List) oldArray0); + if (testFixedArray1 instanceof GenericArray) { + ((GenericArray) testFixedArray1).reset(); + } else { + testFixedArray1 .clear(); + } + } else { + testFixedArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testFixedArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(3); + if (oldArray1 instanceof List) { + testFixedUnionArray1 = ((List) oldArray1); + if (testFixedUnionArray1 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray1).reset(); + } else { + testFixedUnionArray1 .clear(); + } + } else { + testFixedUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testFixedUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema union0; + private final Schema unionOptionSchema0; + private final Schema subField0; + + public FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion_GenericDeserializer_2643982_2643982(Schema readerSchema) { + this.readerSchema = readerSchema; + this.union0 = readerSchema.getField("union").schema(); + this.unionOptionSchema0 = union0 .getTypes().get(1); + this.subField0 = unionOptionSchema0 .getField("subField").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, charSequence1); + } else { + if (unionIndex0 == 3) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + } + return FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == unionOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(unionOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java new file mode 100644 index 000000000..95e7ed9ec --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java @@ -0,0 +1,129 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema mapField0; + private final Schema mapFieldMapValueSchema0; + private final Schema mapFieldValueMapValueSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapField0 = readerSchema.getField("mapField").schema(); + this.mapFieldMapValueSchema0 = mapField0 .getValueType(); + this.mapFieldValueMapValueSchema0 = mapFieldMapValueSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadNestedMap; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadNestedMap = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadNestedMap = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map>> mapField1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), ((int) chunkLen0))); + } else { + Map>> mapFieldReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0); + if (oldMap0 instanceof Map) { + mapFieldReuse0 = ((Map) oldMap0); + } + if (mapFieldReuse0 != (null)) { + mapFieldReuse0 .clear(); + mapField1 = mapFieldReuse0; + } else { + mapField1 = new HashMap>>(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 > mapFieldValue0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, ((int) chunkLen1))); + } else { + Map> mapFieldValueReuse0 = null; + if (null instanceof Map) { + mapFieldValueReuse0 = ((Map) null); + } + if (mapFieldValueReuse0 != (null)) { + mapFieldValueReuse0 .clear(); + mapFieldValue0 = mapFieldValueReuse0; + } else { + mapFieldValue0 = new HashMap>(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0) { + for (int counter2 = 0; (counter2 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, 0)); + } else { + mapFieldValue0 = new HashMap>(0); + } + } + mapField1 .put(key0, mapFieldValue0); + } + chunkLen0 = (decoder.mapNext()); + } while (chunkLen0 > 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), 0)); + } else { + mapField1 = new HashMap>>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadNestedMap.put(0, mapField1); + return FastGenericDeserializerGeneratorTest_shouldReadNestedMap; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java new file mode 100644 index 000000000..c347866c6 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java @@ -0,0 +1,214 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + private final Schema testEnumUnion0; + private final Map enumMappingtestEnum1; + private final Schema testEnumArray0; + private final Map enumMappingtestEnum2; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + private final Map enumMappingtestEnum3; + + public FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(5); + tempEnumMapping0 .put(new Integer(0), new Integer(1)); + tempEnumMapping0 .put(new Integer(1), new Integer(0)); + tempEnumMapping0 .put(new Integer(2), new Integer(4)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + HashMap tempEnumMapping1 = new HashMap(5); + tempEnumMapping1 .put(new Integer(0), new Integer(1)); + tempEnumMapping1 .put(new Integer(1), new Integer(0)); + tempEnumMapping1 .put(new Integer(2), new Integer(4)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + HashMap tempEnumMapping2 = new HashMap(5); + tempEnumMapping2 .put(new Integer(0), new Integer(1)); + tempEnumMapping2 .put(new Integer(1), new Integer(0)); + tempEnumMapping2 .put(new Integer(2), new Integer(4)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + HashMap tempEnumMapping3 = new HashMap(5); + tempEnumMapping3 .put(new Integer(0), new Integer(1)); + tempEnumMapping3 .put(new Integer(1), new Integer(0)); + tempEnumMapping3 .put(new Integer(2), new Integer(4)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(0, enumValue0); + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum1((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(1, null); + } else { + if (unionIndex0 == 1) { + int enumIndex1 = (decoder.readEnum()); + GenericEnumSymbol enumValue1 = null; + Object enumIndexLookupResult1 = enumMappingtestEnum1 .get(enumIndex1); + if (enumIndexLookupResult1 instanceof Integer) { + enumValue1 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult1))); + } else { + if (enumIndexLookupResult1 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult1); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(1, enumValue1); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + if (testEnumArray1 instanceof GenericArray) { + ((GenericArray) testEnumArray1).reset(); + } else { + testEnumArray1 .clear(); + } + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + if (testEnumUnionArray1 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray1).reset(); + } else { + testEnumUnionArray1 .clear(); + } + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testIntUnion0; + private final Schema testStringUnion0; + private final Schema testLongUnion0; + private final Schema testDoubleUnion0; + private final Schema testFloatUnion0; + private final Schema testBooleanUnion0; + private final Schema testBytesUnion0; + + public FastGenericDeserializerGeneratorTest_shouldReadPrimitives_GenericDeserializer_1966544736_1966544736(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testIntUnion0 = readerSchema.getField("testIntUnion").schema(); + this.testStringUnion0 = readerSchema.getField("testStringUnion").schema(); + this.testLongUnion0 = readerSchema.getField("testLongUnion").schema(); + this.testDoubleUnion0 = readerSchema.getField("testDoubleUnion").schema(); + this.testFloatUnion0 = readerSchema.getField("testFloatUnion").schema(); + this.testBooleanUnion0 = readerSchema.getField("testBooleanUnion").schema(); + this.testBytesUnion0 = readerSchema.getField("testBytesUnion").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(0, (decoder.readInt())); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPrimitives; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(1, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(2); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(2, charSequence0); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(3, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(3); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(3, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(4, (decoder.readLong())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(5, null); + } else { + if (unionIndex2 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(5, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex2)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(6, (decoder.readDouble())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(7, null); + } else { + if (unionIndex3 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(7, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex3)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(8, (decoder.readFloat())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(9, null); + } else { + if (unionIndex4 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(9, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex4)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(10, (decoder.readBoolean())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(11, null); + } else { + if (unionIndex5 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(11, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex5)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(12); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(12, byteBuffer0); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(13, null); + } else { + if (unionIndex6 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(13); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(13, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex6)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java new file mode 100644 index 000000000..514004256 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java @@ -0,0 +1,164 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema record10; + private final Schema subField0; + private final Schema intFieldField0; + private final Schema intField0; + private final Schema subField1; + private final Schema recordArray0; + + public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record10 = readerSchema.getField("record1").schema(); + this.subField0 = record10 .getField("subField").schema(); + this.intFieldField0 = record10 .getField("intField").schema(); + this.intField0 = record10 .getField("intField").schema(); + this.subField1 = record10 .getField("subField").schema(); + this.recordArray0 = readerSchema.getField("recordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == record10)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(record10); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + subRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(1); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(1, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex0)); + } + } + subRecord.put(0, null); + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord1(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); + List recordArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); + if (oldArray0 instanceof List) { + recordArray1 = ((List) oldArray0); + if (recordArray1 instanceof GenericArray) { + ((GenericArray) recordArray1).reset(); + } else { + recordArray1 .clear(); + } + } else { + recordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema record10; + private final Schema subField0; + private final Schema record20; + private final Schema intField0; + private final Schema subField1; + private final Schema recordArray0; + + public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1365753944_1274815349(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record10 = readerSchema.getField("record1").schema(); + this.subField0 = record10 .getField("subField").schema(); + this.record20 = readerSchema.getField("record2").schema(); + this.intField0 = record20 .getField("intField").schema(); + this.subField1 = record20 .getField("subField").schema(); + this.recordArray0 = readerSchema.getField("recordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializealiasedSubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializealiasedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord aliasedSubRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == record10)) { + aliasedSubRecord = ((IndexedRecord)(reuse)); + } else { + aliasedSubRecord = new org.apache.avro.generic.GenericData.Record(record10); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + decoder.readInt(); + } else { + throw new RuntimeException(("Illegal union index for 'intField': "+ unionIndex0)); + } + } + populate_aliasedSubRecord0((aliasedSubRecord), (customization), (decoder)); + return aliasedSubRecord; + } + + private void populate_aliasedSubRecord0(IndexedRecord aliasedSubRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + aliasedSubRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = aliasedSubRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + aliasedSubRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); + List recordArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); + if (oldArray0 instanceof List) { + recordArray1 = ((List) oldArray0); + if (recordArray1 instanceof GenericArray) { + ((GenericArray) recordArray1).reset(); + } else { + recordArray1 .clear(); + } + } else { + recordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema recordsArray0; + private final Schema recordsArrayArrayElemSchema0; + private final Schema subField0; + private final Schema recordsMap0; + private final Schema recordsArrayUnion0; + private final Schema recordsArrayUnionOptionSchema0; + private final Schema recordsArrayUnionOptionArrayElemSchema0; + private final Schema recordsMapUnion0; + private final Schema recordsMapUnionOptionSchema0; + private final Schema recordsMapUnionOptionMapValueSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField_GenericDeserializer_1602399407_1602399407(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordsArray0 = readerSchema.getField("recordsArray").schema(); + this.recordsArrayArrayElemSchema0 = recordsArray0 .getElementType(); + this.subField0 = recordsArrayArrayElemSchema0 .getField("subField").schema(); + this.recordsMap0 = readerSchema.getField("recordsMap").schema(); + this.recordsArrayUnion0 = readerSchema.getField("recordsArrayUnion").schema(); + this.recordsArrayUnionOptionSchema0 = recordsArrayUnion0 .getTypes().get(1); + this.recordsArrayUnionOptionArrayElemSchema0 = recordsArrayUnionOptionSchema0 .getElementType(); + this.recordsMapUnion0 = readerSchema.getField("recordsMapUnion").schema(); + this.recordsMapUnionOptionSchema0 = recordsMapUnion0 .getTypes().get(1); + this.recordsMapUnionOptionMapValueSchema0 = recordsMapUnionOptionSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List recordsArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(0); + if (oldArray0 instanceof List) { + recordsArray1 = ((List) oldArray0); + if (recordsArray1 instanceof GenericArray) { + ((GenericArray) recordsArray1).reset(); + } else { + recordsArray1 .clear(); + } + } else { + recordsArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordsArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 recordsMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), ((int) chunkLen1))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap1 = recordsMapReuse0; + } else { + recordsMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), 0)); + } else { + recordsMap1 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(1, recordsMap1); + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(2, null); + } else { + if (unionIndex1 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(2); + if (oldArray1 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray1); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen2), recordsArrayUnionOptionSchema0); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 recordsMapUnionOption0 = null; + long chunkLen3 = (decoder.readMapStart()); + if (chunkLen3 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), ((int) chunkLen3))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); + } + } + do { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(3, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex3)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java new file mode 100644 index 000000000..366bebd95 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java @@ -0,0 +1,394 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema recordsArrayMap0; + private final Schema recordsArrayMapArrayElemSchema0; + private final Schema recordsArrayMapElemMapValueSchema0; + private final Schema recordsArrayMapElemValueOptionSchema0; + private final Schema subField0; + private final Schema recordsMapArray0; + private final Schema recordsMapArrayMapValueSchema0; + private final Schema recordsMapArrayValueArrayElemSchema0; + private final Schema recordsArrayMapUnion0; + private final Schema recordsArrayMapUnionOptionArrayElemSchema0; + private final Schema recordsArrayMapUnionOptionElemMapValueSchema0; + private final Schema recordsMapArrayUnion0; + private final Schema recordsMapArrayUnionOptionSchema0; + private final Schema recordsMapArrayUnionOptionValueArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordsArrayMap0 = readerSchema.getField("recordsArrayMap").schema(); + this.recordsArrayMapArrayElemSchema0 = recordsArrayMap0 .getElementType(); + this.recordsArrayMapElemMapValueSchema0 = recordsArrayMapArrayElemSchema0 .getValueType(); + this.recordsArrayMapElemValueOptionSchema0 = recordsArrayMapElemMapValueSchema0 .getTypes().get(1); + this.subField0 = recordsArrayMapElemValueOptionSchema0 .getField("subField").schema(); + this.recordsMapArray0 = readerSchema.getField("recordsMapArray").schema(); + this.recordsMapArrayMapValueSchema0 = recordsMapArray0 .getValueType(); + this.recordsMapArrayValueArrayElemSchema0 = recordsMapArrayMapValueSchema0 .getElementType(); + this.recordsArrayMapUnion0 = readerSchema.getField("recordsArrayMapUnion").schema(); + this.recordsArrayMapUnionOptionArrayElemSchema0 = recordsArrayMap0 .getElementType(); + this.recordsArrayMapUnionOptionElemMapValueSchema0 = recordsArrayMapUnionOptionArrayElemSchema0 .getValueType(); + this.recordsMapArrayUnion0 = readerSchema.getField("recordsMapArrayUnion").schema(); + this.recordsMapArrayUnionOptionSchema0 = recordsMapArrayUnion0 .getTypes().get(1); + this.recordsMapArrayUnionOptionValueArrayElemSchema0 = recordsMapArrayMapValueSchema0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List> recordsArrayMap1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(0); + if (oldArray0 instanceof List) { + recordsArrayMap1 = ((List) oldArray0); + if (recordsArrayMap1 instanceof GenericArray) { + ((GenericArray) recordsArrayMap1).reset(); + } else { + recordsArrayMap1 .clear(); + } + } else { + recordsArrayMap1 = new org.apache.avro.generic.GenericData.Array>(((int) chunkLen0), recordsArrayMap0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 recordsArrayMapElem0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen1))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap1 .add(recordsArrayMapElem0); + } + chunkLen0 = (decoder.arrayNext()); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(0, recordsArrayMap1); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordsArrayMapElemValueOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(recordsArrayMapElemValueOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray1 = null; + long chunkLen2 = (decoder.readMapStart()); + if (chunkLen2 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), ((int) chunkLen2))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap0); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray1 = recordsMapArrayReuse0; + } else { + recordsMapArray1 = new HashMap>(((int)(((chunkLen2 * 4)+ 2)/ 3))); + } + } + do { + for (int counter2 = 0; (counter2 recordsMapArrayValue0 = null; + long chunkLen3 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen3), recordsMapArrayMapValueSchema0); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), 0)); + } else { + recordsMapArray1 = new HashMap>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(1, recordsMapArray1); + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(2, null); + } else { + if (unionIndex3 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(2); + if (oldArray1 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray1); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new org.apache.avro.generic.GenericData.Array>(((int) chunkLen4), recordsArrayMap0); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArrayMapUnionOptionElem0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen5))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen4 = (decoder.arrayNext()); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(2, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex3)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(3, null); + } else { + if (unionIndex5 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), ((int) chunkLen6))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 recordsMapArrayUnionOptionValue0 = null; + long chunkLen7 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen7), recordsMapArrayMapValueSchema0); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(3, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex5)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java new file mode 100644 index 000000000..ffe74819e --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java @@ -0,0 +1,114 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema record0; + private final Schema recordOptionSchema0; + private final Schema subField0; + private final Schema field0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record0 = readerSchema.getField("record").schema(); + this.recordOptionSchema0 = record0 .getTypes().get(1); + this.subField0 = recordOptionSchema0 .getField("subField").schema(); + this.field0 = readerSchema.getField("field").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'record': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(recordOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(1), (decoder), (customization))); + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(2, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(2); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(2, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex2)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java new file mode 100644 index 000000000..2999bfa74 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java @@ -0,0 +1,256 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testNotRemoved0; + private final Schema testNotRemoved20; + private final Schema subRecord0; + private final Schema subRecordOptionSchema0; + private final Schema testNotRemoved1; + private final Schema testNotRemoved21; + private final Schema subRecordMap0; + private final Schema subRecordArray0; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testNotRemoved0 = readerSchema.getField("testNotRemoved").schema(); + this.testNotRemoved20 = readerSchema.getField("testNotRemoved2").schema(); + this.subRecord0 = readerSchema.getField("subRecord").schema(); + this.subRecordOptionSchema0 = subRecord0 .getTypes().get(1); + this.testNotRemoved1 = subRecordOptionSchema0 .getField("testNotRemoved").schema(); + this.testNotRemoved21 = subRecordOptionSchema0 .getField("testNotRemoved2").schema(); + this.subRecordMap0 = readerSchema.getField("subRecordMap").schema(); + this.subRecordArray0 = readerSchema.getField("subRecordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + } else { + if (unionIndex1 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testRemoved': "+ unionIndex1)); + } + } + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(1, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved2': "+ unionIndex2)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, null); + } else { + if (unionIndex3 == 1) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(2), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex3)); + } + } + Map subRecordMap1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), ((int) chunkLen0))); + } else { + Map subRecordMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3); + if (oldMap0 instanceof Map) { + subRecordMapReuse0 = ((Map) oldMap0); + } + if (subRecordMapReuse0 != (null)) { + subRecordMapReuse0 .clear(); + subRecordMap1 = subRecordMapReuse0; + } else { + subRecordMap1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), 0)); + } else { + subRecordMap1 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(3, subRecordMap1); + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecordOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecordOptionSchema0); + } + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex4 == 1) { + Utf8 charSequence2; + Object oldString2 = subRecord.get(0); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + subRecord.put(0, charSequence2); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex4)); + } + } + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + } else { + if (unionIndex5 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testRemoved': "+ unionIndex5)); + } + } + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + subRecord.put(1, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence3; + Object oldString3 = subRecord.get(1); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + subRecord.put(1, charSequence3); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved2': "+ unionIndex6)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List subRecordArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(4); + if (oldArray0 instanceof List) { + subRecordArray1 = ((List) oldArray0); + if (subRecordArray1 instanceof GenericArray) { + ((GenericArray) subRecordArray1).reset(); + } else { + subRecordArray1 .clear(); + } + } else { + subRecordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), subRecordArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema subRecord0; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord_GenericDeserializer_1090641932_438987109(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.get(0), (decoder), (customization))); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord0); + } + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + populate_subRecord0((subRecord), (customization), (decoder)); + populate_subRecord1((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubSubRecord0(null, (decoder), (customization)); + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + deserializesubSubRecord0(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'test3': "+ unionIndex0)); + } + } + } + + public void deserializesubSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + populate_subSubRecord0((decoder)); + } + + private void populate_subSubRecord0(Decoder decoder) + throws IOException + { + decoder.skipString(); + } + + private void populate_subRecord1(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = subRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + subRecord.put(1, charSequence1); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java new file mode 100644 index 000000000..3cb35e221 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java @@ -0,0 +1,114 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema subRecord10; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord10 = readerSchema.getField("subRecord1").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord10)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord10); + } + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = subRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + subRecord.put(1, charSequence1); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubRecord20(null, (decoder), (customization)); + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + deserializesubRecord20(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord3': "+ unionIndex0)); + } + } + } + + public void deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + populate_subRecord20((decoder)); + } + + private void populate_subRecord20(Decoder decoder) + throws IOException + { + decoder.skipString(); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(1), (decoder), (customization))); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java new file mode 100644 index 000000000..c845cbe57 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java @@ -0,0 +1,60 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java new file mode 100644 index 000000000..0ca4c7227 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java @@ -0,0 +1,60 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java new file mode 100644 index 000000000..3b903bc43 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + throw new AvroTypeException("Found \"long\", expecting [\"null\", \"string\"]"); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java new file mode 100644 index 000000000..e91081739 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java new file mode 100644 index 000000000..a468548dc --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java new file mode 100644 index 000000000..ae8e42f3b --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java new file mode 100644 index 000000000..b7f7ddf1f --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java new file mode 100644 index 000000000..fb54625de --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java new file mode 100644 index 000000000..edba80afa --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java @@ -0,0 +1,71 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_906204958(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_1778260273(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.put(0, null); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_906204958(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.put(0, null); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_2127585735(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + if (unionIndex0 == 1) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java new file mode 100644 index 000000000..80bf2145c --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + if (unionIndex0 == 1) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java new file mode 100644 index 000000000..d4c8cd4a5 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + if (unionIndex0 == 1) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java new file mode 100644 index 000000000..cd9f371d8 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + if (unionIndex0 == 1) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java new file mode 100644 index 000000000..d8985d05f --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java new file mode 100644 index 000000000..ca483552f --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java new file mode 100644 index 000000000..166e451fa --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java new file mode 100644 index 000000000..5b013d8c2 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java new file mode 100644 index 000000000..094924e13 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + this.testOptionSchema1 = test0 .getTypes().get(2); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java new file mode 100644 index 000000000..fab6625e0 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + this.testOptionSchema1 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java new file mode 100644 index 000000000..abe441877 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(2); + this.testOptionSchema1 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java new file mode 100644 index 000000000..1201b01ab --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + this.testOptionSchema1 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastSerdeLogicalTypesDefined_GenericDeserializer_229156053_229156053.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastSerdeLogicalTypesDefined_GenericDeserializer_229156053_229156053.java new file mode 100644 index 000000000..5d633c658 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastSerdeLogicalTypesDefined_GenericDeserializer_229156053_229156053.java @@ -0,0 +1,108 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.time.Instant; +import java.time.LocalDate; +import java.time.LocalTime; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Conversions; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastSerdeLogicalTypesDefined_GenericDeserializer_229156053_229156053 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema timeMillisField0; + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema dateField0; + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema arrayOfUnionOfDateAndTimestampMillis0; + private final Schema arrayOfUnionOfDateAndTimestampMillisArrayElemSchema0; + private final Schema arrayOfUnionOfDateAndTimestampMillisElemOptionSchema0; + private final Schema arrayOfUnionOfDateAndTimestampMillisElemOptionSchema1; + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + + public FastSerdeLogicalTypesDefined_GenericDeserializer_229156053_229156053(Schema readerSchema) { + this.readerSchema = readerSchema; + this.timeMillisField0 = readerSchema.getField("timeMillisField").schema(); + this.dateField0 = readerSchema.getField("dateField").schema(); + this.arrayOfUnionOfDateAndTimestampMillis0 = readerSchema.getField("arrayOfUnionOfDateAndTimestampMillis").schema(); + this.arrayOfUnionOfDateAndTimestampMillisArrayElemSchema0 = arrayOfUnionOfDateAndTimestampMillis0 .getElementType(); + this.arrayOfUnionOfDateAndTimestampMillisElemOptionSchema0 = arrayOfUnionOfDateAndTimestampMillisArrayElemSchema0 .getTypes().get(0); + this.arrayOfUnionOfDateAndTimestampMillisElemOptionSchema1 = arrayOfUnionOfDateAndTimestampMillisArrayElemSchema0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesDefined0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastSerdeLogicalTypesDefined0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastSerdeLogicalTypesDefined; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastSerdeLogicalTypesDefined = ((IndexedRecord)(reuse)); + } else { + FastSerdeLogicalTypesDefined = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + LocalTime convertedValue0 = ((LocalTime) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis)); + FastSerdeLogicalTypesDefined.put(0, convertedValue0); + populate_FastSerdeLogicalTypesDefined0((FastSerdeLogicalTypesDefined), (customization), (decoder)); + return FastSerdeLogicalTypesDefined; + } + + private void populate_FastSerdeLogicalTypesDefined0(IndexedRecord FastSerdeLogicalTypesDefined, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + LocalDate convertedValue1 = ((LocalDate) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date)); + FastSerdeLogicalTypesDefined.put(1, convertedValue1); + List arrayOfUnionOfDateAndTimestampMillis1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastSerdeLogicalTypesDefined.get(2); + if (oldArray0 instanceof List) { + arrayOfUnionOfDateAndTimestampMillis1 = ((List) oldArray0); + if (arrayOfUnionOfDateAndTimestampMillis1 instanceof GenericArray) { + ((GenericArray) arrayOfUnionOfDateAndTimestampMillis1).reset(); + } else { + arrayOfUnionOfDateAndTimestampMillis1 .clear(); + } + } else { + arrayOfUnionOfDateAndTimestampMillis1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), arrayOfUnionOfDateAndTimestampMillis0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + + public FastSerdeLogicalTypesDefined_SpecificDeserializer_229156053_229156053(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined deserialize(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesDefined0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined deserializeFastSerdeLogicalTypesDefined0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined FastSerdeLogicalTypesDefined; + if ((reuse)!= null) { + FastSerdeLogicalTypesDefined = ((com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined)(reuse)); + } else { + FastSerdeLogicalTypesDefined = new com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined(); + } + LocalTime convertedValue0 = ((LocalTime) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis)); + FastSerdeLogicalTypesDefined.put(0, convertedValue0); + populate_FastSerdeLogicalTypesDefined0((FastSerdeLogicalTypesDefined), (customization), (decoder)); + return FastSerdeLogicalTypesDefined; + } + + private void populate_FastSerdeLogicalTypesDefined0(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined FastSerdeLogicalTypesDefined, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + LocalDate convertedValue1 = ((LocalDate) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date)); + FastSerdeLogicalTypesDefined.put(1, convertedValue1); + List arrayOfUnionOfDateAndTimestampMillis0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastSerdeLogicalTypesDefined.get(2); + if (oldArray0 instanceof List) { + arrayOfUnionOfDateAndTimestampMillis0 = ((List) oldArray0); + if (arrayOfUnionOfDateAndTimestampMillis0 instanceof GenericArray) { + ((GenericArray) arrayOfUnionOfDateAndTimestampMillis0).reset(); + } else { + arrayOfUnionOfDateAndTimestampMillis0 .clear(); + } + } else { + arrayOfUnionOfDateAndTimestampMillis0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.LocalTimestampMillisConversion conversion_local_timestamp_millis = new org.apache.avro.data.TimeConversions.LocalTimestampMillisConversion(); + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final Conversions.DecimalConversion conversion_decimal = new Conversions.DecimalConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema unionOfArrayAndMap0; + private final Schema unionOfArrayAndMapOptionSchema0; + private final Schema unionOfArrayAndMapOptionArrayElemSchema0; + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema unionOfArrayAndMapOptionSchema1; + private final Schema unionOfArrayAndMapOptionMapValueSchema0; + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema mapOfUnionsOfDateAndTimestampMillis0; + private final Schema mapOfUnionsOfDateAndTimestampMillisMapValueSchema0; + private final Schema mapOfUnionsOfDateAndTimestampMillisValueOptionSchema0; + private final Schema mapOfUnionsOfDateAndTimestampMillisValueOptionSchema1; + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + private final Schema timestampMillisMap0; + private final Schema timestampMillisMapMapValueSchema0; + private final Schema nullableArrayOfDates0; + private final Schema nullableArrayOfDatesOptionSchema0; + private final Schema nullableArrayOfDatesOptionArrayElemSchema0; + private final Schema arrayOfDatesArrayElemSchema0; + private final Schema unionOfDecimalOrDate0; + private final Schema unionOfDecimalOrDateOptionSchema0; + private final Schema logicalTypeSchema_120893213 = Schema.parse("{\"type\":\"bytes\",\"logicalType\":\"decimal\",\"precision\":4,\"scale\":2}"); + private final Schema unionOfDecimalOrDateOptionSchema1; + private final Schema timestampMillisField0; + private final Schema timestampMicrosField0; + private final Schema logicalTypeSchema__1252781617 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-micros\"}"); + private final Schema timeMillisField0; + private final Schema timeMicrosField0; + private final Schema logicalTypeSchema__1515894331 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"time-micros\"}"); + private final Schema dateField0; + private final Schema nestedLocalTimestampMillis0; + private final Schema nestedTimestamp0; + private final Schema logicalTypeSchema__250645780 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"local-timestamp-millis\"}"); + private final Schema nullableNestedTimestamp0; + private final Schema nullableNestedTimestampOptionSchema0; + private final Schema nullableUnionOfDateAndLocalTimestamp0; + private final Schema nullableUnionOfDateAndLocalTimestampOptionSchema0; + private final Schema nullableUnionOfDateAndLocalTimestampOptionSchema1; + private final Schema unionOfDateAndLocalTimestamp0; + private final Schema unionOfDateAndLocalTimestampOptionSchema0; + private final Schema unionOfDateAndLocalTimestampOptionSchema1; + + public FastSerdeLogicalTypesTest1_GenericDeserializer_1007574890_1007574890(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOfArrayAndMap0 = readerSchema.getField("unionOfArrayAndMap").schema(); + this.unionOfArrayAndMapOptionSchema0 = unionOfArrayAndMap0 .getTypes().get(0); + this.unionOfArrayAndMapOptionArrayElemSchema0 = unionOfArrayAndMapOptionSchema0 .getElementType(); + this.unionOfArrayAndMapOptionSchema1 = unionOfArrayAndMap0 .getTypes().get(1); + this.unionOfArrayAndMapOptionMapValueSchema0 = unionOfArrayAndMapOptionSchema1 .getValueType(); + this.mapOfUnionsOfDateAndTimestampMillis0 = readerSchema.getField("mapOfUnionsOfDateAndTimestampMillis").schema(); + this.mapOfUnionsOfDateAndTimestampMillisMapValueSchema0 = mapOfUnionsOfDateAndTimestampMillis0 .getValueType(); + this.mapOfUnionsOfDateAndTimestampMillisValueOptionSchema0 = mapOfUnionsOfDateAndTimestampMillisMapValueSchema0 .getTypes().get(0); + this.mapOfUnionsOfDateAndTimestampMillisValueOptionSchema1 = mapOfUnionsOfDateAndTimestampMillisMapValueSchema0 .getTypes().get(1); + this.timestampMillisMap0 = readerSchema.getField("timestampMillisMap").schema(); + this.timestampMillisMapMapValueSchema0 = timestampMillisMap0 .getValueType(); + this.nullableArrayOfDates0 = readerSchema.getField("nullableArrayOfDates").schema(); + this.nullableArrayOfDatesOptionSchema0 = nullableArrayOfDates0 .getTypes().get(1); + this.nullableArrayOfDatesOptionArrayElemSchema0 = nullableArrayOfDatesOptionSchema0 .getElementType(); + this.arrayOfDatesArrayElemSchema0 = nullableArrayOfDatesOptionSchema0 .getElementType(); + this.unionOfDecimalOrDate0 = readerSchema.getField("unionOfDecimalOrDate").schema(); + this.unionOfDecimalOrDateOptionSchema0 = unionOfDecimalOrDate0 .getTypes().get(0); + this.unionOfDecimalOrDateOptionSchema1 = unionOfDecimalOrDate0 .getTypes().get(1); + this.timestampMillisField0 = readerSchema.getField("timestampMillisField").schema(); + this.timestampMicrosField0 = readerSchema.getField("timestampMicrosField").schema(); + this.timeMillisField0 = readerSchema.getField("timeMillisField").schema(); + this.timeMicrosField0 = readerSchema.getField("timeMicrosField").schema(); + this.dateField0 = readerSchema.getField("dateField").schema(); + this.nestedLocalTimestampMillis0 = readerSchema.getField("nestedLocalTimestampMillis").schema(); + this.nestedTimestamp0 = nestedLocalTimestampMillis0 .getField("nestedTimestamp").schema(); + this.nullableNestedTimestamp0 = nestedLocalTimestampMillis0 .getField("nullableNestedTimestamp").schema(); + this.nullableNestedTimestampOptionSchema0 = nullableNestedTimestamp0 .getTypes().get(1); + this.nullableUnionOfDateAndLocalTimestamp0 = nestedLocalTimestampMillis0 .getField("nullableUnionOfDateAndLocalTimestamp").schema(); + this.nullableUnionOfDateAndLocalTimestampOptionSchema0 = nullableUnionOfDateAndLocalTimestamp0 .getTypes().get(1); + this.nullableUnionOfDateAndLocalTimestampOptionSchema1 = nullableUnionOfDateAndLocalTimestamp0 .getTypes().get(2); + this.unionOfDateAndLocalTimestamp0 = nestedLocalTimestampMillis0 .getField("unionOfDateAndLocalTimestamp").schema(); + this.unionOfDateAndLocalTimestampOptionSchema0 = unionOfDateAndLocalTimestamp0 .getTypes().get(0); + this.unionOfDateAndLocalTimestampOptionSchema1 = unionOfDateAndLocalTimestamp0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesTest10((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastSerdeLogicalTypesTest10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastSerdeLogicalTypesTest1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastSerdeLogicalTypesTest1 = ((IndexedRecord)(reuse)); + } else { + FastSerdeLogicalTypesTest1 = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + List unionOfArrayAndMapOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastSerdeLogicalTypesTest1 .get(0); + if (oldArray0 instanceof List) { + unionOfArrayAndMapOption0 = ((List) oldArray0); + unionOfArrayAndMapOption0 .clear(); + } else { + unionOfArrayAndMapOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), unionOfArrayAndMapOptionSchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 unionOfArrayAndMapOption1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOfArrayAndMapOption1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(0), ((int) chunkLen1))); + } else { + Map unionOfArrayAndMapOptionReuse0 = null; + Object oldMap0 = FastSerdeLogicalTypesTest1 .get(0); + if (oldMap0 instanceof Map) { + unionOfArrayAndMapOptionReuse0 = ((Map) oldMap0); + } + if (unionOfArrayAndMapOptionReuse0 != (null)) { + unionOfArrayAndMapOptionReuse0 .clear(); + unionOfArrayAndMapOption1 = unionOfArrayAndMapOptionReuse0; + } else { + unionOfArrayAndMapOption1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOfArrayAndMapOption1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(0), 0)); + } else { + unionOfArrayAndMapOption1 = new HashMap(0); + } + } + FastSerdeLogicalTypesTest1 .put(0, unionOfArrayAndMapOption1); + } else { + throw new RuntimeException(("Illegal union index for 'unionOfArrayAndMap': "+ unionIndex0)); + } + } + populate_FastSerdeLogicalTypesTest10((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest11((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest12((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest13((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest14((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest15((FastSerdeLogicalTypesTest1), (customization), (decoder)); + return FastSerdeLogicalTypesTest1; + } + + private void populate_FastSerdeLogicalTypesTest10(IndexedRecord FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map mapOfUnionsOfDateAndTimestampMillis1 = null; + long chunkLen2 = (decoder.readMapStart()); + if (chunkLen2 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapOfUnionsOfDateAndTimestampMillis1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(1), ((int) chunkLen2))); + } else { + Map mapOfUnionsOfDateAndTimestampMillisReuse0 = null; + Object oldMap1 = FastSerdeLogicalTypesTest1 .get(1); + if (oldMap1 instanceof Map) { + mapOfUnionsOfDateAndTimestampMillisReuse0 = ((Map) oldMap1); + } + if (mapOfUnionsOfDateAndTimestampMillisReuse0 != (null)) { + mapOfUnionsOfDateAndTimestampMillisReuse0 .clear(); + mapOfUnionsOfDateAndTimestampMillis1 = mapOfUnionsOfDateAndTimestampMillisReuse0; + } else { + mapOfUnionsOfDateAndTimestampMillis1 = new HashMap(((int)(((chunkLen2 * 4)+ 2)/ 3))); + } + } + do { + for (int counter2 = 0; (counter2 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapOfUnionsOfDateAndTimestampMillis1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(1), 0)); + } else { + mapOfUnionsOfDateAndTimestampMillis1 = new HashMap(0); + } + } + FastSerdeLogicalTypesTest1 .put(1, mapOfUnionsOfDateAndTimestampMillis1); + Map timestampMillisMap1 = null; + long chunkLen3 = (decoder.readMapStart()); + if (chunkLen3 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + timestampMillisMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(2), ((int) chunkLen3))); + } else { + Map timestampMillisMapReuse0 = null; + Object oldMap2 = FastSerdeLogicalTypesTest1 .get(2); + if (oldMap2 instanceof Map) { + timestampMillisMapReuse0 = ((Map) oldMap2); + } + if (timestampMillisMapReuse0 != (null)) { + timestampMillisMapReuse0 .clear(); + timestampMillisMap1 = timestampMillisMapReuse0; + } else { + timestampMillisMap1 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); + } + } + do { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + timestampMillisMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(2), 0)); + } else { + timestampMillisMap1 = new HashMap(0); + } + } + FastSerdeLogicalTypesTest1 .put(2, timestampMillisMap1); + } + + private void populate_FastSerdeLogicalTypesTest11(IndexedRecord FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastSerdeLogicalTypesTest1 .put(3, null); + } else { + if (unionIndex2 == 1) { + List nullableArrayOfDatesOption0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray1 = FastSerdeLogicalTypesTest1 .get(3); + if (oldArray1 instanceof List) { + nullableArrayOfDatesOption0 = ((List) oldArray1); + nullableArrayOfDatesOption0 .clear(); + } else { + nullableArrayOfDatesOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen4), nullableArrayOfDatesOptionSchema0); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 arrayOfDates0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray2 = FastSerdeLogicalTypesTest1 .get(4); + if (oldArray2 instanceof List) { + arrayOfDates0 = ((List) oldArray2); + arrayOfDates0 .clear(); + } else { + arrayOfDates0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen5), nullableArrayOfDatesOptionSchema0); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 +{ + + private final Schema readerSchema; + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.LocalTimestampMillisConversion conversion_local_timestamp_millis = new org.apache.avro.data.TimeConversions.LocalTimestampMillisConversion(); + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final Conversions.DecimalConversion conversion_decimal = new Conversions.DecimalConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + private final Schema logicalTypeSchema_120893213 = Schema.parse("{\"type\":\"bytes\",\"logicalType\":\"decimal\",\"precision\":4,\"scale\":2}"); + private final Schema logicalTypeSchema__1252781617 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-micros\"}"); + private final Schema logicalTypeSchema__1515894331 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"time-micros\"}"); + private final Schema logicalTypeSchema__250645780 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"local-timestamp-millis\"}"); + + public FastSerdeLogicalTypesTest1_SpecificDeserializer_1007574890_1007574890(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 deserialize(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesTest10((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 deserializeFastSerdeLogicalTypesTest10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1; + if ((reuse)!= null) { + FastSerdeLogicalTypesTest1 = ((com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1)(reuse)); + } else { + FastSerdeLogicalTypesTest1 = new com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + List unionOfArrayAndMapOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastSerdeLogicalTypesTest1 .get(0); + if (oldArray0 instanceof List) { + unionOfArrayAndMapOption0 = ((List) oldArray0); + unionOfArrayAndMapOption0 .clear(); + } else { + unionOfArrayAndMapOption0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 unionOfArrayAndMapOption1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOfArrayAndMapOption1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(0), ((int) chunkLen1))); + } else { + Map unionOfArrayAndMapOptionReuse0 = null; + Object oldMap0 = FastSerdeLogicalTypesTest1 .get(0); + if (oldMap0 instanceof Map) { + unionOfArrayAndMapOptionReuse0 = ((Map) oldMap0); + } + if (unionOfArrayAndMapOptionReuse0 != (null)) { + unionOfArrayAndMapOptionReuse0 .clear(); + unionOfArrayAndMapOption1 = unionOfArrayAndMapOptionReuse0; + } else { + unionOfArrayAndMapOption1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOfArrayAndMapOption1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(0), 0)); + } else { + unionOfArrayAndMapOption1 = new HashMap(0); + } + } + FastSerdeLogicalTypesTest1 .put(0, unionOfArrayAndMapOption1); + } else { + throw new RuntimeException(("Illegal union index for 'unionOfArrayAndMap': "+ unionIndex0)); + } + } + populate_FastSerdeLogicalTypesTest10((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest11((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest12((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest13((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest14((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest15((FastSerdeLogicalTypesTest1), (customization), (decoder)); + return FastSerdeLogicalTypesTest1; + } + + private void populate_FastSerdeLogicalTypesTest10(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map mapOfUnionsOfDateAndTimestampMillis0 = null; + long chunkLen2 = (decoder.readMapStart()); + if (chunkLen2 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapOfUnionsOfDateAndTimestampMillis0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(1), ((int) chunkLen2))); + } else { + Map mapOfUnionsOfDateAndTimestampMillisReuse0 = null; + Object oldMap1 = FastSerdeLogicalTypesTest1 .get(1); + if (oldMap1 instanceof Map) { + mapOfUnionsOfDateAndTimestampMillisReuse0 = ((Map) oldMap1); + } + if (mapOfUnionsOfDateAndTimestampMillisReuse0 != (null)) { + mapOfUnionsOfDateAndTimestampMillisReuse0 .clear(); + mapOfUnionsOfDateAndTimestampMillis0 = mapOfUnionsOfDateAndTimestampMillisReuse0; + } else { + mapOfUnionsOfDateAndTimestampMillis0 = new HashMap(((int)(((chunkLen2 * 4)+ 2)/ 3))); + } + } + do { + for (int counter2 = 0; (counter2 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapOfUnionsOfDateAndTimestampMillis0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(1), 0)); + } else { + mapOfUnionsOfDateAndTimestampMillis0 = new HashMap(0); + } + } + FastSerdeLogicalTypesTest1 .put(1, mapOfUnionsOfDateAndTimestampMillis0); + Map timestampMillisMap0 = null; + long chunkLen3 = (decoder.readMapStart()); + if (chunkLen3 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + timestampMillisMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(2), ((int) chunkLen3))); + } else { + Map timestampMillisMapReuse0 = null; + Object oldMap2 = FastSerdeLogicalTypesTest1 .get(2); + if (oldMap2 instanceof Map) { + timestampMillisMapReuse0 = ((Map) oldMap2); + } + if (timestampMillisMapReuse0 != (null)) { + timestampMillisMapReuse0 .clear(); + timestampMillisMap0 = timestampMillisMapReuse0; + } else { + timestampMillisMap0 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); + } + } + do { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + timestampMillisMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(2), 0)); + } else { + timestampMillisMap0 = new HashMap(0); + } + } + FastSerdeLogicalTypesTest1 .put(2, timestampMillisMap0); + } + + private void populate_FastSerdeLogicalTypesTest11(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastSerdeLogicalTypesTest1 .put(3, null); + } else { + if (unionIndex2 == 1) { + List nullableArrayOfDatesOption0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray1 = FastSerdeLogicalTypesTest1 .get(3); + if (oldArray1 instanceof List) { + nullableArrayOfDatesOption0 = ((List) oldArray1); + nullableArrayOfDatesOption0 .clear(); + } else { + nullableArrayOfDatesOption0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 arrayOfDates0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray2 = FastSerdeLogicalTypesTest1 .get(4); + if (oldArray2 instanceof List) { + arrayOfDates0 = ((List) oldArray2); + arrayOfDates0 .clear(); + } else { + arrayOfDates0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 +{ + + private final Schema readerSchema; + private final Schema arrayOfUnionOfDateAndTimestampMillis0; + private final Schema arrayOfUnionOfDateAndTimestampMillisArrayElemSchema0; + + public FastSerdeLogicalTypesUndefined_GenericDeserializer_1982763418_1982763418(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayOfUnionOfDateAndTimestampMillis0 = readerSchema.getField("arrayOfUnionOfDateAndTimestampMillis").schema(); + this.arrayOfUnionOfDateAndTimestampMillisArrayElemSchema0 = arrayOfUnionOfDateAndTimestampMillis0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesUndefined0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastSerdeLogicalTypesUndefined0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastSerdeLogicalTypesUndefined; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastSerdeLogicalTypesUndefined = ((IndexedRecord)(reuse)); + } else { + FastSerdeLogicalTypesUndefined = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastSerdeLogicalTypesUndefined.put(0, (decoder.readInt())); + populate_FastSerdeLogicalTypesUndefined0((FastSerdeLogicalTypesUndefined), (customization), (decoder)); + return FastSerdeLogicalTypesUndefined; + } + + private void populate_FastSerdeLogicalTypesUndefined0(IndexedRecord FastSerdeLogicalTypesUndefined, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastSerdeLogicalTypesUndefined.put(1, (decoder.readInt())); + List arrayOfUnionOfDateAndTimestampMillis1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastSerdeLogicalTypesUndefined.get(2); + if (oldArray0 instanceof List) { + arrayOfUnionOfDateAndTimestampMillis1 = ((List) oldArray0); + if (arrayOfUnionOfDateAndTimestampMillis1 instanceof GenericArray) { + ((GenericArray) arrayOfUnionOfDateAndTimestampMillis1).reset(); + } else { + arrayOfUnionOfDateAndTimestampMillis1 .clear(); + } + } else { + arrayOfUnionOfDateAndTimestampMillis1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), arrayOfUnionOfDateAndTimestampMillis0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public FastSerdeLogicalTypesUndefined_SpecificDeserializer_1982763418_1982763418(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined deserialize(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesUndefined0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined deserializeFastSerdeLogicalTypesUndefined0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined FastSerdeLogicalTypesUndefined; + if ((reuse)!= null) { + FastSerdeLogicalTypesUndefined = ((com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined)(reuse)); + } else { + FastSerdeLogicalTypesUndefined = new com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined(); + } + FastSerdeLogicalTypesUndefined.put(0, (decoder.readInt())); + populate_FastSerdeLogicalTypesUndefined0((FastSerdeLogicalTypesUndefined), (customization), (decoder)); + return FastSerdeLogicalTypesUndefined; + } + + private void populate_FastSerdeLogicalTypesUndefined0(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined FastSerdeLogicalTypesUndefined, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastSerdeLogicalTypesUndefined.put(1, (decoder.readInt())); + List arrayOfUnionOfDateAndTimestampMillis0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastSerdeLogicalTypesUndefined.get(2); + if (oldArray0 instanceof List) { + arrayOfUnionOfDateAndTimestampMillis0 = ((List) oldArray0); + if (arrayOfUnionOfDateAndTimestampMillis0 instanceof GenericArray) { + ((GenericArray) arrayOfUnionOfDateAndTimestampMillis0).reset(); + } else { + arrayOfUnionOfDateAndTimestampMillis0 .clear(); + } + } else { + arrayOfUnionOfDateAndTimestampMillis0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyInReaderSchemaTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyInReaderSchemaTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence1; + Object oldString1 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + if (testStringArray1 instanceof GenericArray) { + ((GenericArray) testStringArray1).reset(); + } else { + testStringArray1 .clear(); + } + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java new file mode 100644 index 000000000..d4b83595d --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java @@ -0,0 +1,134 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyInReaderSchemaTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyInReaderSchemaTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + String charSequence0 = (decoder).readString(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, null); + } else { + if (unionIndex0 == 1) { + String charSequence1 = (decoder).readString(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + if (testStringArray1 instanceof GenericArray) { + ((GenericArray) testStringArray1).reset(); + } else { + testStringArray1 .clear(); + } + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java new file mode 100644 index 000000000..ab1e5311e --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java @@ -0,0 +1,134 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + String charSequence0 = (decoder).readString(); + FastStringableTest_javaStringPropertyTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyTest0((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyTest1((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyTest; + } + + private void populate_FastStringableTest_javaStringPropertyTest0(IndexedRecord FastStringableTest_javaStringPropertyTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyTest.put(1, null); + } else { + if (unionIndex0 == 1) { + String charSequence1 = (decoder).readString(); + FastStringableTest_javaStringPropertyTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + if (testStringArray1 instanceof GenericArray) { + ((GenericArray) testStringArray1).reset(); + } else { + testStringArray1 .clear(); + } + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java new file mode 100644 index 000000000..9ca18e45a --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java @@ -0,0 +1,1115 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex7 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex7)); + } + } + List testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + if (testFixedArray0 instanceof GenericArray) { + ((GenericArray) testFixedArray0).reset(); + } else { + testFixedArray0 .clear(); + } + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + if (testFixedUnionArray0 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray0).reset(); + } else { + testFixedUnionArray0 .clear(); + } + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + if (testEnumArray0 instanceof GenericArray) { + ((GenericArray) testEnumArray0).reset(); + } else { + testEnumArray0 .clear(); + } + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + if (testEnumUnionArray0 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray0).reset(); + } else { + testEnumUnionArray0 .clear(); + } + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + if (recordsArray0 instanceof GenericArray) { + ((GenericArray) recordsArray0).reset(); + } else { + recordsArray0 .clear(); + } + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + if (recordsArrayMap0 instanceof GenericArray) { + ((GenericArray) recordsArrayMap0).reset(); + } else { + recordsArrayMap0 .clear(); + } + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + if (stringArray0 instanceof GenericArray) { + ((GenericArray) stringArray0).reset(); + } else { + stringArray0 .clear(); + } + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema mapMapValueSchema0; + private final Schema mapValueOptionSchema0; + private final Schema field0; + + public Map_of_UNION_GenericDeserializer_2140000109_2140000109(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapValueSchema0 = readerSchema.getValueType(); + this.mapValueOptionSchema0 = mapMapValueSchema0 .getTypes().get(1); + this.field0 = mapValueOptionSchema0 .getField("field").schema(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapValueOptionSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapValueOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + record.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = record.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + record.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex1)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/Map_of_UNION_SpecificDeserializer_971650236_971650236.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/Map_of_UNION_SpecificDeserializer_971650236_971650236.java new file mode 100644 index 000000000..c67b5e96c --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/Map_of_UNION_SpecificDeserializer_971650236_971650236.java @@ -0,0 +1,1125 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_UNION_SpecificDeserializer_971650236_971650236 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Map_of_UNION_SpecificDeserializer_971650236_971650236(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex1)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex2)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex3)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex4)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex5 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex5)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex6 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex6)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex7 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex7)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + List testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + if (testFixedArray0 instanceof GenericArray) { + ((GenericArray) testFixedArray0).reset(); + } else { + testFixedArray0 .clear(); + } + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + if (testFixedUnionArray0 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray0).reset(); + } else { + testFixedUnionArray0 .clear(); + } + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + if (testEnumArray0 instanceof GenericArray) { + ((GenericArray) testEnumArray0).reset(); + } else { + testEnumArray0 .clear(); + } + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + if (testEnumUnionArray0 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray0).reset(); + } else { + testEnumUnionArray0 .clear(); + } + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + if (recordsArray0 instanceof GenericArray) { + ((GenericArray) recordsArray0).reset(); + } else { + recordsArray0 .clear(); + } + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex15 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex17)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + if (recordsArrayMap0 instanceof GenericArray) { + ((GenericArray) recordsArrayMap0).reset(); + } else { + recordsArrayMap0 .clear(); + } + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex21 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex21)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex23 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex23)); + } + } + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex25 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex25 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex25 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex25)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + if (stringArray0 instanceof GenericArray) { + ((GenericArray) stringArray0).reset(); + } else { + stringArray0 .clear(); + } + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema unionOptionMapValueSchema0; + + public Map_of_record_GenericDeserializer_1223705675_568621313(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOptionMapValueSchema0 = readerSchema.getValueType(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":{\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}}"); + } else { + if (unionIndex0 == 1) { + Map unionOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map unionOptionReuse0 = null; + if ((reuse) instanceof Map) { + unionOptionReuse0 = ((Map)(reuse)); + } + if (unionOptionReuse0 != (null)) { + unionOptionReuse0 .clear(); + unionOption0 = unionOptionReuse0; + } else { + unionOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + unionOption0 = new HashMap(0); + } + } + return unionOption0; + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == unionOptionMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(unionOptionMapValueSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/Map_of_record_GenericDeserializer_1677529043_1677529043.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/Map_of_record_GenericDeserializer_1677529043_1677529043.java new file mode 100644 index 000000000..ae555ad62 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/Map_of_record_GenericDeserializer_1677529043_1677529043.java @@ -0,0 +1,95 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_record_GenericDeserializer_1677529043_1677529043 + implements FastDeserializer> +{ + + private final Schema readerSchema; + private final Schema mapMapValueSchema0; + private final Schema field0; + + public Map_of_record_GenericDeserializer_1677529043_1677529043(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapValueSchema0 = readerSchema.getValueType(); + this.field0 = mapMapValueSchema0 .getField("field").schema(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapMapValueSchema0); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + record.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = record.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + record.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java new file mode 100644 index 000000000..33d497716 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java @@ -0,0 +1,61 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserialize(com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRecordWithLargeUnionField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserializeRecordWithLargeUnionField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField RecordWithLargeUnionField; + if ((reuse)!= null) { + RecordWithLargeUnionField = ((com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField)(reuse)); + } else { + RecordWithLargeUnionField = new com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Utf8 charSequence0; + Object oldString0 = RecordWithLargeUnionField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RecordWithLargeUnionField.put(0, charSequence0); + } else { + if (unionIndex0 == 1) { + RecordWithLargeUnionField.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + throw new AvroTypeException(new StringBuilder().append("Found").append(" \"byt").append("es\", ").append("expec").append("ting ").append("[\"str").append("ing\",").append(" \"int").append("\"]").toString()); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + } + return RecordWithLargeUnionField; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java new file mode 100644 index 000000000..619a02804 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java @@ -0,0 +1,47 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; + if ((reuse)!= null) { + RemovedTypesTestRecord = ((com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord)(reuse)); + } else { + RemovedTypesTestRecord = new com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord(); + } + Utf8 charSequence0; + Object oldString0 = RemovedTypesTestRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RemovedTypesTestRecord.put(0, charSequence0); + return RemovedTypesTestRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java new file mode 100644 index 000000000..0452693fa --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java @@ -0,0 +1,406 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; + if ((reuse)!= null) { + RemovedTypesTestRecord = ((com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord)(reuse)); + } else { + RemovedTypesTestRecord = new com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord(); + } + Utf8 charSequence0; + Object oldString0 = RemovedTypesTestRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RemovedTypesTestRecord.put(0, charSequence0); + populate_RemovedTypesTestRecord0((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord1((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord2((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord3((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord4((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord5((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord6((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord7((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord8((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord9((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord10((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord11((RemovedTypesTestRecord), (customization), (decoder)); + return RemovedTypesTestRecord; + } + + private void populate_RemovedTypesTestRecord0(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.skipBytes(); + long chunkLen0 = (decoder.readArrayStart()); + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 0) { + do { + for (int counter1 = 0; (counter1 0); + } + } + + private void populate_RemovedTypesTestRecord2(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen2 = (decoder.readArrayStart()); + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 0) { + do { + for (int counter3 = 0; (counter3 0); + } + } + + private void populate_RemovedTypesTestRecord3(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.skipFixed(1); + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + } else { + if (unionIndex3 == 1) { + decoder.skipFixed(1); + } else { + throw new RuntimeException(("Illegal union index for 'removedFixedUnion': "+ unionIndex3)); + } + } + } + + private void populate_RemovedTypesTestRecord4(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen4 = (decoder.readArrayStart()); + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 0) { + do { + for (int counter5 = 0; (counter5 0); + } + } + + private void populate_RemovedTypesTestRecord5(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen6 = (decoder.readArrayStart()); + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 0) { + do { + for (int counter7 = 0; (counter7 0); + } + } + + private void populate_RemovedTypesTestRecord6(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.readEnum(); + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + } else { + if (unionIndex6 == 1) { + decoder.readEnum(); + } else { + throw new RuntimeException(("Illegal union index for 'removedEnumUnion': "+ unionIndex6)); + } + } + } + + private void populate_RemovedTypesTestRecord7(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen8 = (decoder.readArrayStart()); + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 0) { + do { + for (int counter9 = 0; (counter9 0); + } + } + + private void populate_RemovedTypesTestRecord8(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen10 = (decoder.readArrayStart()); + while (chunkLen10 > 0) { + for (int counter10 = 0; (counter10 0) { + do { + for (int counter11 = 0; (counter11 0); + } + } + + private void populate_RemovedTypesTestRecord9(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializeRemovedSubRecord0(null, (decoder), (customization)); + int unionIndex9 = (decoder.readIndex()); + if (unionIndex9 == 0) { + decoder.readNull(); + } else { + if (unionIndex9 == 1) { + deserializeRemovedSubRecord0(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'removedSubRecordUnion': "+ unionIndex9)); + } + } + } + + public void deserializeRemovedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + } + + private void populate_RemovedTypesTestRecord10(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen12 = (decoder.readArrayStart()); + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0) { + for (int counter13 = 0; (counter13 0) { + do { + for (int counter14 = 0; (counter14 0); + } + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + do { + for (int counter15 = 0; (counter15 0); + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java new file mode 100644 index 000000000..c05ed3ba7 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java @@ -0,0 +1,176 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class SplitRecordTest1_SpecificDeserializer_1718878379_595582209 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public SplitRecordTest1_SpecificDeserializer_1718878379_595582209(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeSplitRecordTest10((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserializeSplitRecordTest10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 SplitRecordTest1; + if ((reuse)!= null) { + SplitRecordTest1 = ((com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1)(reuse)); + } else { + SplitRecordTest1 = new com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1(); + } + SplitRecordTest1 .put(0, deserializeFullRecord0(SplitRecordTest1 .get(0), (decoder), (customization))); + populate_SplitRecordTest10((SplitRecordTest1), (customization), (decoder)); + return SplitRecordTest1; + } + + public com.linkedin.avro.fastserde.generated.avro.FullRecord deserializeFullRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.FullRecord FullRecord; + if ((reuse)!= null) { + FullRecord = ((com.linkedin.avro.fastserde.generated.avro.FullRecord)(reuse)); + } else { + FullRecord = new com.linkedin.avro.fastserde.generated.avro.FullRecord(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FullRecord.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FullRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FullRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex0)); + } + } + FullRecord.put(1, null); + return FullRecord; + } + + private void populate_SplitRecordTest10(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 SplitRecordTest1, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + SplitRecordTest1 .put(1, deserializeFullRecord1(SplitRecordTest1 .get(1), (decoder), (customization))); + List record30 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = SplitRecordTest1 .get(2); + if (oldArray0 instanceof List) { + record30 = ((List) oldArray0); + if (record30 instanceof GenericArray) { + ((GenericArray) record30).reset(); + } else { + record30 .clear(); + } + } else { + record30 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public SplitRecordTest2_SpecificDeserializer_595582209_1718878379(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeSplitRecordTest20((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserializeSplitRecordTest20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 SplitRecordTest2; + if ((reuse)!= null) { + SplitRecordTest2 = ((com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2)(reuse)); + } else { + SplitRecordTest2 = new com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2(); + } + SplitRecordTest2 .put(0, deserializeStringRecord0(SplitRecordTest2 .get(0), (decoder), (customization))); + populate_SplitRecordTest20((SplitRecordTest2), (customization), (decoder)); + return SplitRecordTest2; + } + + public StringRecord deserializeStringRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + StringRecord IntRecord; + if ((reuse)!= null) { + IntRecord = ((StringRecord)(reuse)); + } else { + IntRecord = new StringRecord(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + IntRecord.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = IntRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + IntRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex0)); + } + } + populate_IntRecord0((IntRecord), (customization), (decoder)); + return IntRecord; + } + + private void populate_IntRecord0(StringRecord IntRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + } else { + if (unionIndex1 == 1) { + decoder.readInt(); + } else { + throw new RuntimeException(("Illegal union index for 'field2': "+ unionIndex1)); + } + } + } + + private void populate_SplitRecordTest20(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 SplitRecordTest2, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + SplitRecordTest2 .put(1, deserializeIntRecord0(SplitRecordTest2 .get(1), (decoder), (customization))); + List record30 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = SplitRecordTest2 .get(2); + if (oldArray0 instanceof List) { + record30 = ((List) oldArray0); + if (record30 instanceof GenericArray) { + ((GenericArray) record30).reset(); + } else { + record30 .clear(); + } + } else { + record30 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public StringableRecord_SpecificDeserializer_842267318_842267318(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserialize(com.linkedin.avro.fastserde.generated.avro.StringableRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + try { + return deserializeStringableRecord0((reuse), (decoder), (customization)); + } catch (NumberFormatException e) { + throw new AvroRuntimeException(e); + } catch (MalformedURLException e) { + throw new AvroRuntimeException(e); + } catch (URISyntaxException e) { + throw new AvroRuntimeException(e); + } + } + + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserializeStringableRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord; + if ((reuse)!= null) { + StringableRecord = ((com.linkedin.avro.fastserde.generated.avro.StringableRecord)(reuse)); + } else { + StringableRecord = new com.linkedin.avro.fastserde.generated.avro.StringableRecord(); + } + BigInteger charSequence0 = new BigInteger((decoder.readString())); + StringableRecord.put(0, charSequence0); + populate_StringableRecord0((StringableRecord), (customization), (decoder)); + populate_StringableRecord1((StringableRecord), (customization), (decoder)); + populate_StringableRecord2((StringableRecord), (customization), (decoder)); + populate_StringableRecord3((StringableRecord), (customization), (decoder)); + populate_StringableRecord4((StringableRecord), (customization), (decoder)); + return StringableRecord; + } + + private void populate_StringableRecord0(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, URISyntaxException + { + BigDecimal charSequence1 = new BigDecimal((decoder.readString())); + StringableRecord.put(1, charSequence1); + URI charSequence2 = new URI((decoder.readString())); + StringableRecord.put(2, charSequence2); + } + + private void populate_StringableRecord1(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + URL charSequence3 = new URL((decoder.readString())); + StringableRecord.put(3, charSequence3); + File charSequence4 = new File((decoder.readString())); + StringableRecord.put(4, charSequence4); + } + + private void populate_StringableRecord2(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + List urlArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = StringableRecord.get(5); + if (oldArray0 instanceof List) { + urlArray0 = ((List) oldArray0); + if (urlArray0 instanceof GenericArray) { + ((GenericArray) urlArray0).reset(); + } else { + urlArray0 .clear(); + } + } else { + urlArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 urlMap0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), ((int) chunkLen1))); + } else { + Map urlMapReuse0 = null; + Object oldMap0 = StringableRecord.get(6); + if (oldMap0 instanceof Map) { + urlMapReuse0 = ((Map) oldMap0); + } + if (urlMapReuse0 != (null)) { + urlMapReuse0 .clear(); + urlMap0 = urlMapReuse0; + } else { + urlMap0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), 0)); + } else { + urlMap0 = new HashMap(0); + } + } + StringableRecord.put(6, urlMap0); + } + + private void populate_StringableRecord3(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + StringableRecord.put(7, deserializeStringableSubRecord0(StringableRecord.get(7), (decoder), (customization))); + StringableRecord.put(8, deserializeAnotherSubRecord0(StringableRecord.get(8), (decoder), (customization))); + } + + public com.linkedin.avro.fastserde.generated.avro.StringableSubRecord deserializeStringableSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException, URISyntaxException + { + com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord; + if ((reuse)!= null) { + StringableSubRecord = ((com.linkedin.avro.fastserde.generated.avro.StringableSubRecord)(reuse)); + } else { + StringableSubRecord = new com.linkedin.avro.fastserde.generated.avro.StringableSubRecord(); + } + URI charSequence7 = new URI((decoder.readString())); + StringableSubRecord.put(0, charSequence7); + populate_StringableSubRecord0((StringableSubRecord), (customization), (decoder)); + return StringableSubRecord; + } + + private void populate_StringableSubRecord0(com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, URISyntaxException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + StringableSubRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence8; + Object oldString0 = StringableSubRecord.get(1); + if (oldString0 instanceof Utf8) { + charSequence8 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence8 = (decoder).readString(null); + } + StringableSubRecord.put(1, charSequence8); + } else { + if (unionIndex0 == 2) { + StringableSubRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'nullStringIntUnion': "+ unionIndex0)); + } + } + } + } + + public com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord deserializeAnotherSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException, URISyntaxException + { + com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord AnotherSubRecord; + if ((reuse)!= null) { + AnotherSubRecord = ((com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord)(reuse)); + } else { + AnotherSubRecord = new com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord(); + } + AnotherSubRecord.put(0, deserializeStringableSubRecord0(AnotherSubRecord.get(0), (decoder), (customization))); + return AnotherSubRecord; + } + + private void populate_StringableRecord4(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + StringableRecord.put(9, null); + } else { + if (unionIndex1 == 1) { + String charSequence9 = (decoder).readString(); + StringableRecord.put(9, charSequence9); + } else { + throw new RuntimeException(("Illegal union index for 'stringUnion': "+ unionIndex1)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java new file mode 100644 index 000000000..db457b6e2 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java @@ -0,0 +1,46 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class TestArrayOfFloats_GenericDeserializer_1408566797_1408566797 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema array_of_float0; + + public TestArrayOfFloats_GenericDeserializer_1408566797_1408566797(Schema readerSchema) { + this.readerSchema = readerSchema; + this.array_of_float0 = readerSchema.getField("array_of_float").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestArrayOfFloats0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestArrayOfFloats0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord TestArrayOfFloats; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + TestArrayOfFloats = ((IndexedRecord)(reuse)); + } else { + TestArrayOfFloats = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + PrimitiveFloatList array_of_float1 = null; + array_of_float1 = ((PrimitiveFloatList) BufferBackedPrimitiveFloatList.readPrimitiveFloatArray(TestArrayOfFloats.get(0), (decoder))); + TestArrayOfFloats.put(0, array_of_float1); + return TestArrayOfFloats; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/TestRecord_GenericDeserializer_473555078_473555078.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/TestRecord_GenericDeserializer_473555078_473555078.java new file mode 100644 index 000000000..b983e49c5 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/TestRecord_GenericDeserializer_473555078_473555078.java @@ -0,0 +1,78 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_GenericDeserializer_473555078_473555078 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema map_field0; + + public TestRecord_GenericDeserializer_473555078_473555078(Schema readerSchema) { + this.readerSchema = readerSchema; + this.map_field0 = readerSchema.getField("map_field").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord TestRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + TestRecord = ((IndexedRecord)(reuse)); + } else { + TestRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map map_field1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), ((int) chunkLen0))); + } else { + Map map_fieldReuse0 = null; + Object oldMap0 = TestRecord.get(0); + if (oldMap0 instanceof Map) { + map_fieldReuse0 = ((Map) oldMap0); + } + if (map_fieldReuse0 != (null)) { + map_fieldReuse0 .clear(); + map_field1 = map_fieldReuse0; + } else { + map_field1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), 0)); + } else { + map_field1 = new HashMap(0); + } + } + TestRecord.put(0, map_field1); + return TestRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/TestRecord_SpecificDeserializer_1898726132_553331077.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/TestRecord_SpecificDeserializer_1898726132_553331077.java new file mode 100644 index 000000000..cf3e8127c --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/TestRecord_SpecificDeserializer_1898726132_553331077.java @@ -0,0 +1,1079 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_1898726132_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Map enumMappingTestEnum0; + private final Map enumMappingTestEnum1; + private final Map enumMappingTestEnum2; + private final Map enumMappingTestEnum3; + + public TestRecord_SpecificDeserializer_1898726132_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + HashMap tempEnumMapping0 = new HashMap(5); + tempEnumMapping0 .put(new Integer(0), new Integer(4)); + tempEnumMapping0 .put(new Integer(1), new Integer(3)); + tempEnumMapping0 .put(new Integer(2), new Integer(1)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + HashMap tempEnumMapping1 = new HashMap(5); + tempEnumMapping1 .put(new Integer(0), new Integer(4)); + tempEnumMapping1 .put(new Integer(1), new Integer(3)); + tempEnumMapping1 .put(new Integer(2), new Integer(1)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + HashMap tempEnumMapping2 = new HashMap(5); + tempEnumMapping2 .put(new Integer(0), new Integer(4)); + tempEnumMapping2 .put(new Integer(1), new Integer(3)); + tempEnumMapping2 .put(new Integer(2), new Integer(1)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + HashMap tempEnumMapping3 = new HashMap(5); + tempEnumMapping3 .put(new Integer(0), new Integer(4)); + tempEnumMapping3 .put(new Integer(1), new Integer(3)); + tempEnumMapping3 .put(new Integer(2), new Integer(1)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + ArrayList defaultArray0 = new ArrayList(); + TestRecord.put(33, defaultArray0); + ArrayList defaultArray1 = new ArrayList(); + TestRecord.put(34, defaultArray1); + ArrayList defaultArray2 = new ArrayList(); + TestRecord.put(35, defaultArray2); + ArrayList defaultArray3 = new ArrayList(); + TestRecord.put(36, defaultArray3); + ArrayList defaultArray4 = new ArrayList(); + TestRecord.put(37, defaultArray4); + ArrayList defaultArray5 = new ArrayList(); + TestRecord.put(38, defaultArray5); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + } else { + if (unionIndex7 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'removedField': "+ unionIndex7)); + } + } + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + } + + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + if (testFixedArray0 instanceof GenericArray) { + ((GenericArray) testFixedArray0).reset(); + } else { + testFixedArray0 .clear(); + } + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + if (testFixedUnionArray0 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray0).reset(); + } else { + testFixedUnionArray0 .clear(); + } + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + if (testEnumArray0 instanceof GenericArray) { + ((GenericArray) testEnumArray0).reset(); + } else { + testEnumArray0 .clear(); + } + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + if (testEnumUnionArray0 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray0).reset(); + } else { + testEnumUnionArray0 .clear(); + } + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + if (recordsArray0 instanceof GenericArray) { + ((GenericArray) recordsArray0).reset(); + } else { + recordsArray0 .clear(); + } + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + } + + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex16 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex18)); + } + } + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + if (recordsArrayMap0 instanceof GenericArray) { + ((GenericArray) recordsArrayMap0).reset(); + } else { + recordsArrayMap0 .clear(); + } + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex22 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex24 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex24)); + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex26 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex26 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex26 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex26)); + } + } + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/TestRecord_SpecificDeserializer_1991094399_553331077.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/TestRecord_SpecificDeserializer_1991094399_553331077.java new file mode 100644 index 000000000..f0921db2b --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/TestRecord_SpecificDeserializer_1991094399_553331077.java @@ -0,0 +1,1083 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_1991094399_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Map enumMappingTestEnum0; + private final Map enumMappingTestEnum1; + private final Map enumMappingTestEnum2; + private final Map enumMappingTestEnum3; + + public TestRecord_SpecificDeserializer_1991094399_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + HashMap tempEnumMapping0 = new HashMap(6); + tempEnumMapping0 .put(new Integer(0), new Integer(4)); + tempEnumMapping0 .put(new Integer(1), new Integer(3)); + tempEnumMapping0 .put(new Integer(2), new Integer(1)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(0)); + tempEnumMapping0 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + HashMap tempEnumMapping1 = new HashMap(6); + tempEnumMapping1 .put(new Integer(0), new Integer(4)); + tempEnumMapping1 .put(new Integer(1), new Integer(3)); + tempEnumMapping1 .put(new Integer(2), new Integer(1)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(0)); + tempEnumMapping1 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + HashMap tempEnumMapping2 = new HashMap(6); + tempEnumMapping2 .put(new Integer(0), new Integer(4)); + tempEnumMapping2 .put(new Integer(1), new Integer(3)); + tempEnumMapping2 .put(new Integer(2), new Integer(1)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(0)); + tempEnumMapping2 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + HashMap tempEnumMapping3 = new HashMap(6); + tempEnumMapping3 .put(new Integer(0), new Integer(4)); + tempEnumMapping3 .put(new Integer(1), new Integer(3)); + tempEnumMapping3 .put(new Integer(2), new Integer(1)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(0)); + tempEnumMapping3 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + ArrayList defaultArray0 = new ArrayList(); + TestRecord.put(33, defaultArray0); + ArrayList defaultArray1 = new ArrayList(); + TestRecord.put(34, defaultArray1); + ArrayList defaultArray2 = new ArrayList(); + TestRecord.put(35, defaultArray2); + ArrayList defaultArray3 = new ArrayList(); + TestRecord.put(36, defaultArray3); + ArrayList defaultArray4 = new ArrayList(); + TestRecord.put(37, defaultArray4); + ArrayList defaultArray5 = new ArrayList(); + TestRecord.put(38, defaultArray5); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + } else { + if (unionIndex7 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'removedField': "+ unionIndex7)); + } + } + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + } + + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + if (testFixedArray0 instanceof GenericArray) { + ((GenericArray) testFixedArray0).reset(); + } else { + testFixedArray0 .clear(); + } + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + if (testFixedUnionArray0 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray0).reset(); + } else { + testFixedUnionArray0 .clear(); + } + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + if (testEnumArray0 instanceof GenericArray) { + ((GenericArray) testEnumArray0).reset(); + } else { + testEnumArray0 .clear(); + } + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + if (testEnumUnionArray0 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray0).reset(); + } else { + testEnumUnionArray0 .clear(); + } + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + if (recordsArray0 instanceof GenericArray) { + ((GenericArray) recordsArray0).reset(); + } else { + recordsArray0 .clear(); + } + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + } + + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex16 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex18)); + } + } + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + if (recordsArrayMap0 instanceof GenericArray) { + ((GenericArray) recordsArrayMap0).reset(); + } else { + recordsArrayMap0 .clear(); + } + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex22 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex24 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex24)); + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex26 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex26 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex26 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex26)); + } + } + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/TestRecord_SpecificDeserializer_553331077_553331077.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/TestRecord_SpecificDeserializer_553331077_553331077.java new file mode 100644 index 000000000..e20d1ffe9 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/TestRecord_SpecificDeserializer_553331077_553331077.java @@ -0,0 +1,1084 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_553331077_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public TestRecord_SpecificDeserializer_553331077_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex7 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex7)); + } + } + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + if (testFixedArray0 instanceof GenericArray) { + ((GenericArray) testFixedArray0).reset(); + } else { + testFixedArray0 .clear(); + } + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + if (testFixedUnionArray0 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray0).reset(); + } else { + testFixedUnionArray0 .clear(); + } + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + if (testEnumArray0 instanceof GenericArray) { + ((GenericArray) testEnumArray0).reset(); + } else { + testEnumArray0 .clear(); + } + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + if (testEnumUnionArray0 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray0).reset(); + } else { + testEnumUnionArray0 .clear(); + } + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + if (recordsArray0 instanceof GenericArray) { + ((GenericArray) recordsArray0).reset(); + } else { + recordsArray0 .clear(); + } + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + if (recordsArrayMap0 instanceof GenericArray) { + ((GenericArray) recordsArrayMap0).reset(); + } else { + recordsArrayMap0 .clear(); + } + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen16 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 stringArray0 = null; + long chunkLen20 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + if (stringArray0 instanceof GenericArray) { + ((GenericArray) stringArray0).reset(); + } else { + stringArray0 .clear(); + } + } else { + stringArray0 = new ArrayList(((int) chunkLen20)); + } + while (chunkLen20 > 0) { + for (int counter20 = 0; (counter20 +{ + + private final Schema readerSchema; + private final Schema recordRecordSchema0; + + public UNION_GenericDeserializer_1971822364_1672473580(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordRecordSchema0 = readerSchema.getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordRecordSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(recordRecordSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/UNION_GenericDeserializer_2018567528_1606337179.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/UNION_GenericDeserializer_2018567528_1606337179.java new file mode 100644 index 000000000..a3c060c44 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/UNION_GenericDeserializer_2018567528_1606337179.java @@ -0,0 +1,68 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class UNION_GenericDeserializer_2018567528_1606337179 + implements FastDeserializer> +{ + + private final Schema readerSchema; + private final Schema arrayArraySchema0; + private final Schema arrayArrayElemSchema0; + + public UNION_GenericDeserializer_2018567528_1606337179(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArraySchema0 = readerSchema.getTypes().get(1); + this.arrayArrayElemSchema0 = arrayArraySchema0 .getElementType(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + if (array0 instanceof GenericArray) { + ((GenericArray) array0).reset(); + } else { + array0 .clear(); + } + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), arrayArraySchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + private final Schema mapMapSchema0; + private final Schema mapMapValueSchema0; + + public UNION_GenericDeserializer_568621313_1223705675(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapSchema0 = readerSchema.getTypes().get(1); + this.mapMapValueSchema0 = mapMapSchema0 .getValueType(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapMapValueSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java new file mode 100644 index 000000000..ee7cf5b1c --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.MyEnumV1; +import com.linkedin.avro.fastserde.generated.avro.MyEnumV2; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserialize(com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeUnionOfRecordsWithSameNameEnumField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserializeUnionOfRecordsWithSameNameEnumField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField UnionOfRecordsWithSameNameEnumField; + if ((reuse)!= null) { + UnionOfRecordsWithSameNameEnumField = ((com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField)(reuse)); + } else { + UnionOfRecordsWithSameNameEnumField = new com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV10(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV20(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + return UnionOfRecordsWithSameNameEnumField; + } + + public com.linkedin.avro.fastserde.generated.avro.MyRecordV1 deserializeMyRecordV10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.MyRecordV1 MyRecordV1; + if ((reuse)!= null) { + MyRecordV1 = ((com.linkedin.avro.fastserde.generated.avro.MyRecordV1)(reuse)); + } else { + MyRecordV1 = new com.linkedin.avro.fastserde.generated.avro.MyRecordV1(); + } + MyRecordV1 .put(0, Enums.getConstant(MyEnumV1 .class, (decoder.readEnum()))); + return MyRecordV1; + } + + public com.linkedin.avro.fastserde.generated.avro.MyRecordV2 deserializeMyRecordV20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.MyRecordV2 MyRecordV2; + if ((reuse)!= null) { + MyRecordV2 = ((com.linkedin.avro.fastserde.generated.avro.MyRecordV2)(reuse)); + } else { + MyRecordV2 = new com.linkedin.avro.fastserde.generated.avro.MyRecordV2(); + } + MyRecordV2 .put(0, Enums.getConstant(MyEnumV2 .class, (decoder.readEnum()))); + return MyRecordV2; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/recordName_GenericDeserializer_1743054079_1743054079.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/recordName_GenericDeserializer_1743054079_1743054079.java new file mode 100644 index 000000000..bd8ae31cd --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/recordName_GenericDeserializer_1743054079_1743054079.java @@ -0,0 +1,67 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class recordName_GenericDeserializer_1743054079_1743054079 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema unionField0; + + public recordName_GenericDeserializer_1743054079_1743054079(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionField0 = readerSchema.getField("unionField").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecordName0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecordName0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord recordName; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + recordName = ((IndexedRecord)(reuse)); + } else { + recordName = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = recordName.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + recordName.put(0, charSequence0); + populate_recordName0((recordName), (customization), (decoder)); + return recordName; + } + + private void populate_recordName0(IndexedRecord recordName, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + recordName.put(1, null); + } else { + if (unionIndex0 == 1) { + recordName.put(1, deserializerecordName0(recordName.get(1), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1025741720_1557256887.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1025741720_1557256887.java new file mode 100644 index 000000000..b50e5bf24 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1025741720_1557256887.java @@ -0,0 +1,96 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1025741720_1557256887 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_1025741720_1557256887(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + Map someIntsOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } + } + record.put(0, someIntsOption0); + } else { + throw new RuntimeException(("Illegal union index for 'someInts': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1126840752_2099305627.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1126840752_2099305627.java new file mode 100644 index 000000000..6e209f6cd --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1126840752_2099305627.java @@ -0,0 +1,50 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1126840752_2099305627 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1126840752_2099305627(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + record.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 1) { + throw new AvroTypeException("Found \"string\", expecting \"int\""); + } else { + throw new RuntimeException(("Illegal union index for 'someField': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1191367445_653449771.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1191367445_653449771.java new file mode 100644 index 000000000..dd540d2b8 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1191367445_653449771.java @@ -0,0 +1,69 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1191367445_653449771 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_1191367445_653449771(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList someIntsOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someIntsOption0 = ((PrimitiveIntList) oldArray0); + someIntsOption0 .clear(); + } else { + someIntsOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1373882843_1971822364(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + record.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'someInt': "+ unionIndex0)); + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1556659421_711533897.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1556659421_711533897.java new file mode 100644 index 000000000..e55a88c63 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1556659421_711533897.java @@ -0,0 +1,72 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1556659421_711533897 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema subRecord0; + + public record_GenericDeserializer_1556659421_711533897(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"subRecord\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"subRecord\",\"fields\":[{\"name\":\"someInt1\",\"type\":\"int\",\"doc\":\"\"},{\"name\":\"someInt2\",\"type\":\"int\",\"doc\":\"\"}]}"); + } else { + if (unionIndex0 == 1) { + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex0)); + } + } + return record; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord0); + } + subRecord.put(0, (decoder.readInt())); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + subRecord.put(1, (decoder.readInt())); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1557256887_1025741720.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1557256887_1025741720.java new file mode 100644 index 000000000..b70ead60f --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1557256887_1025741720.java @@ -0,0 +1,81 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1557256887_1025741720 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsMapSchema0; + private final Schema someIntsMapValueSchema0; + + public record_GenericDeserializer_1557256887_1025741720(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsMapSchema0 = someInts0 .getTypes().get(1); + this.someIntsMapValueSchema0 = someIntsMapSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map someInts1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } + } + record.put(0, someInts1); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1557256887_753570467.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1557256887_753570467.java new file mode 100644 index 000000000..770ef901c --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1557256887_753570467.java @@ -0,0 +1,79 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1557256887_753570467 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsMapSchema0; + + public record_GenericDeserializer_1557256887_753570467(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsMapSchema0 = someInts0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map someInts1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } + } + record.put(0, someInts1); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1672473580_1971822364.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1672473580_1971822364.java new file mode 100644 index 000000000..e841902de --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1672473580_1971822364.java @@ -0,0 +1,50 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1672473580_1971822364 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1672473580_1971822364(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}"); + } else { + if (unionIndex0 == 1) { + return deserializerecord0((reuse), (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1971822364_1373882843.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1971822364_1373882843.java new file mode 100644 index 000000000..ae6f5558b --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_1971822364_1373882843.java @@ -0,0 +1,42 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1971822364_1373882843 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInt0; + + public record_GenericDeserializer_1971822364_1373882843(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInt0 = readerSchema.getField("someInt").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_653449771_1191367445.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_653449771_1191367445.java new file mode 100644 index 000000000..570185253 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_653449771_1191367445.java @@ -0,0 +1,61 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_653449771_1191367445 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsArraySchema0; + + public record_GenericDeserializer_653449771_1191367445(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsArraySchema0 = someInts0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + PrimitiveIntList someInts1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someInts1 = ((PrimitiveIntList) oldArray0); + someInts1 .clear(); + } else { + someInts1 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsArraySchema0; + private final Schema someIntsArrayElemSchema0; + + public record_GenericDeserializer_653449771_813379571(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsArraySchema0 = someInts0 .getTypes().get(1); + this.someIntsArrayElemSchema0 = someIntsArraySchema0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List someInts1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof List) { + someInts1 = ((List) oldArray0); + someInts1 .clear(); + } else { + someInts1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), someIntsArraySchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema subRecord0; + private final Schema subRecordRecordSchema0; + + public record_GenericDeserializer_711533897_1556659421(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + this.subRecordRecordSchema0 = subRecord0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); + return record; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecordRecordSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecordRecordSchema0); + } + subRecord.put(0, (decoder.readInt())); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + subRecord.put(1, (decoder.readInt())); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_753570467_1557256887.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_753570467_1557256887.java new file mode 100644 index 000000000..89387b60f --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_753570467_1557256887.java @@ -0,0 +1,87 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_753570467_1557256887 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_753570467_1557256887(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + Map someIntsOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } + } + record.put(0, someIntsOption0); + } else { + throw new RuntimeException(("Illegal union index for 'someInts': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_813379571_653449771.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_813379571_653449771.java new file mode 100644 index 000000000..d1b8ca444 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_10/record_GenericDeserializer_813379571_653449771.java @@ -0,0 +1,87 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_813379571_653449771 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_813379571_653449771(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList someIntsOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someIntsOption0 = ((PrimitiveIntList) oldArray0); + if (someIntsOption0 instanceof GenericArray) { + ((GenericArray) someIntsOption0).reset(); + } else { + someIntsOption0 .clear(); + } + } else { + someIntsOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + + public testRecord_GenericDeserializer_1146484089_1256982207(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(3); + tempEnumMapping0 .put(new Integer(0), new Integer(0)); + tempEnumMapping0 .put(new Integer(1), new Integer(1)); + tempEnumMapping0 .put(new Integer(2), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.testEnum: No match for C")); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializetestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializetestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord testRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + testRecord = ((IndexedRecord)(reuse)); + } else { + testRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + testRecord.put(0, enumValue0); + return testRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/Array_of_BOOLEAN_GenericSerializer_869749973.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/Array_of_BOOLEAN_GenericSerializer_869749973.java new file mode 100644 index 000000000..07f8aab2b --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/Array_of_BOOLEAN_GenericSerializer_869749973.java @@ -0,0 +1,41 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.io.Encoder; + +public class Array_of_BOOLEAN_GenericSerializer_869749973 + implements FastSerializer> +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveBooleanList) { + PrimitiveBooleanList primitiveList0 = ((PrimitiveBooleanList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveDoubleList) { + PrimitiveDoubleList primitiveList0 = ((PrimitiveDoubleList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveFloatList) { + PrimitiveFloatList primitiveList0 = ((PrimitiveFloatList) array0); + if (primitiveList0 instanceof BufferBackedPrimitiveFloatList) { + BufferBackedPrimitiveFloatList bufferBackedPrimitiveFloatList = ((BufferBackedPrimitiveFloatList) primitiveList0); + bufferBackedPrimitiveFloatList.writeFloats((encoder)); + } else { + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList0 = ((PrimitiveIntList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveLongList) { + PrimitiveLongList primitiveList0 = ((PrimitiveLongList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (int counter0 = 0; (counter0 ) data).get(counter0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/Array_of_record_GenericSerializer_477614132.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/Array_of_record_GenericSerializer_477614132.java new file mode 100644 index 000000000..e567befcf --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/Array_of_record_GenericSerializer_477614132.java @@ -0,0 +1,53 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Array_of_record_GenericSerializer_477614132 + implements FastSerializer> +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (int counter0 = 0; (counter0 ) data).get(counter0); + serializeRecord0(record0, (encoder), (customization)); + } + } + (encoder).writeArrayEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java new file mode 100644 index 000000000..68b26a174 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java @@ -0,0 +1,4527 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(1))); + (encoder).writeInt(((Integer) data.get(2))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(3))); + (encoder).writeInt(((Integer) data.get(4))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(5))); + (encoder).writeInt(((Integer) data.get(6))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(7))); + (encoder).writeInt(((Integer) data.get(8))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(9))); + (encoder).writeInt(((Integer) data.get(10))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(11))); + (encoder).writeInt(((Integer) data.get(12))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(13))); + (encoder).writeInt(((Integer) data.get(14))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(15))); + (encoder).writeInt(((Integer) data.get(16))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(17))); + (encoder).writeInt(((Integer) data.get(18))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(19))); + (encoder).writeInt(((Integer) data.get(20))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(21))); + (encoder).writeInt(((Integer) data.get(22))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(23))); + (encoder).writeInt(((Integer) data.get(24))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(25))); + (encoder).writeInt(((Integer) data.get(26))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(27))); + (encoder).writeInt(((Integer) data.get(28))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(29))); + (encoder).writeInt(((Integer) data.get(30))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(31))); + (encoder).writeInt(((Integer) data.get(32))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(33))); + (encoder).writeInt(((Integer) data.get(34))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(35))); + (encoder).writeInt(((Integer) data.get(36))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(37))); + (encoder).writeInt(((Integer) data.get(38))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(39))); + (encoder).writeInt(((Integer) data.get(40))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(41))); + (encoder).writeInt(((Integer) data.get(42))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(43))); + (encoder).writeInt(((Integer) data.get(44))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(45))); + (encoder).writeInt(((Integer) data.get(46))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(47))); + (encoder).writeInt(((Integer) data.get(48))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(49))); + (encoder).writeInt(((Integer) data.get(50))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(51))); + (encoder).writeInt(((Integer) data.get(52))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(53))); + (encoder).writeInt(((Integer) data.get(54))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(55))); + (encoder).writeInt(((Integer) data.get(56))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(57))); + (encoder).writeInt(((Integer) data.get(58))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(59))); + (encoder).writeInt(((Integer) data.get(60))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(61))); + (encoder).writeInt(((Integer) data.get(62))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(63))); + (encoder).writeInt(((Integer) data.get(64))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(65))); + (encoder).writeInt(((Integer) data.get(66))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(67))); + (encoder).writeInt(((Integer) data.get(68))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(69))); + (encoder).writeInt(((Integer) data.get(70))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(71))); + (encoder).writeInt(((Integer) data.get(72))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(73))); + (encoder).writeInt(((Integer) data.get(74))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(75))); + (encoder).writeInt(((Integer) data.get(76))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(77))); + (encoder).writeInt(((Integer) data.get(78))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(79))); + (encoder).writeInt(((Integer) data.get(80))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(81))); + (encoder).writeInt(((Integer) data.get(82))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(83))); + (encoder).writeInt(((Integer) data.get(84))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(85))); + (encoder).writeInt(((Integer) data.get(86))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(87))); + (encoder).writeInt(((Integer) data.get(88))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(89))); + (encoder).writeInt(((Integer) data.get(90))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(91))); + (encoder).writeInt(((Integer) data.get(92))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(93))); + (encoder).writeInt(((Integer) data.get(94))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(95))); + (encoder).writeInt(((Integer) data.get(96))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(97))); + (encoder).writeInt(((Integer) data.get(98))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(99))); + (encoder).writeInt(((Integer) data.get(100))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(101))); + (encoder).writeInt(((Integer) data.get(102))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(103))); + (encoder).writeInt(((Integer) data.get(104))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(105))); + (encoder).writeInt(((Integer) data.get(106))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(107))); + (encoder).writeInt(((Integer) data.get(108))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(109))); + (encoder).writeInt(((Integer) data.get(110))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(111))); + (encoder).writeInt(((Integer) data.get(112))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(113))); + (encoder).writeInt(((Integer) data.get(114))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(115))); + (encoder).writeInt(((Integer) data.get(116))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(117))); + (encoder).writeInt(((Integer) data.get(118))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(119))); + (encoder).writeInt(((Integer) data.get(120))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(121))); + (encoder).writeInt(((Integer) data.get(122))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(123))); + (encoder).writeInt(((Integer) data.get(124))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(125))); + (encoder).writeInt(((Integer) data.get(126))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(127))); + (encoder).writeInt(((Integer) data.get(128))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(129))); + (encoder).writeInt(((Integer) data.get(130))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(131))); + (encoder).writeInt(((Integer) data.get(132))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(133))); + (encoder).writeInt(((Integer) data.get(134))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(135))); + (encoder).writeInt(((Integer) data.get(136))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(137))); + (encoder).writeInt(((Integer) data.get(138))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(139))); + (encoder).writeInt(((Integer) data.get(140))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(141))); + (encoder).writeInt(((Integer) data.get(142))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(143))); + (encoder).writeInt(((Integer) data.get(144))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(145))); + (encoder).writeInt(((Integer) data.get(146))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(147))); + (encoder).writeInt(((Integer) data.get(148))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(149))); + (encoder).writeInt(((Integer) data.get(150))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(151))); + (encoder).writeInt(((Integer) data.get(152))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(153))); + (encoder).writeInt(((Integer) data.get(154))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(155))); + (encoder).writeInt(((Integer) data.get(156))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(157))); + (encoder).writeInt(((Integer) data.get(158))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(159))); + (encoder).writeInt(((Integer) data.get(160))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(161))); + (encoder).writeInt(((Integer) data.get(162))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(163))); + (encoder).writeInt(((Integer) data.get(164))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(165))); + (encoder).writeInt(((Integer) data.get(166))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(167))); + (encoder).writeInt(((Integer) data.get(168))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(169))); + (encoder).writeInt(((Integer) data.get(170))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(171))); + (encoder).writeInt(((Integer) data.get(172))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(173))); + (encoder).writeInt(((Integer) data.get(174))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(175))); + (encoder).writeInt(((Integer) data.get(176))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(177))); + (encoder).writeInt(((Integer) data.get(178))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(179))); + (encoder).writeInt(((Integer) data.get(180))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(181))); + (encoder).writeInt(((Integer) data.get(182))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(183))); + (encoder).writeInt(((Integer) data.get(184))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(185))); + (encoder).writeInt(((Integer) data.get(186))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(187))); + (encoder).writeInt(((Integer) data.get(188))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(189))); + (encoder).writeInt(((Integer) data.get(190))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(191))); + (encoder).writeInt(((Integer) data.get(192))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(193))); + (encoder).writeInt(((Integer) data.get(194))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(195))); + (encoder).writeInt(((Integer) data.get(196))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(197))); + (encoder).writeInt(((Integer) data.get(198))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(199))); + (encoder).writeInt(((Integer) data.get(200))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(201))); + (encoder).writeInt(((Integer) data.get(202))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(203))); + (encoder).writeInt(((Integer) data.get(204))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(205))); + (encoder).writeInt(((Integer) data.get(206))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(207))); + (encoder).writeInt(((Integer) data.get(208))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(209))); + (encoder).writeInt(((Integer) data.get(210))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(211))); + (encoder).writeInt(((Integer) data.get(212))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(213))); + (encoder).writeInt(((Integer) data.get(214))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(215))); + (encoder).writeInt(((Integer) data.get(216))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(217))); + (encoder).writeInt(((Integer) data.get(218))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(219))); + (encoder).writeInt(((Integer) data.get(220))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(221))); + (encoder).writeInt(((Integer) data.get(222))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(223))); + (encoder).writeInt(((Integer) data.get(224))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(225))); + (encoder).writeInt(((Integer) data.get(226))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(227))); + (encoder).writeInt(((Integer) data.get(228))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(229))); + (encoder).writeInt(((Integer) data.get(230))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(231))); + (encoder).writeInt(((Integer) data.get(232))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(233))); + (encoder).writeInt(((Integer) data.get(234))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(235))); + (encoder).writeInt(((Integer) data.get(236))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(237))); + (encoder).writeInt(((Integer) data.get(238))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(239))); + (encoder).writeInt(((Integer) data.get(240))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(241))); + (encoder).writeInt(((Integer) data.get(242))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(243))); + (encoder).writeInt(((Integer) data.get(244))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(245))); + (encoder).writeInt(((Integer) data.get(246))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(247))); + (encoder).writeInt(((Integer) data.get(248))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(249))); + (encoder).writeInt(((Integer) data.get(250))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(251))); + (encoder).writeInt(((Integer) data.get(252))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(253))); + (encoder).writeInt(((Integer) data.get(254))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(255))); + (encoder).writeInt(((Integer) data.get(256))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(257))); + (encoder).writeInt(((Integer) data.get(258))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(259))); + (encoder).writeInt(((Integer) data.get(260))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(261))); + (encoder).writeInt(((Integer) data.get(262))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(263))); + (encoder).writeInt(((Integer) data.get(264))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(265))); + (encoder).writeInt(((Integer) data.get(266))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(267))); + (encoder).writeInt(((Integer) data.get(268))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(269))); + (encoder).writeInt(((Integer) data.get(270))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(271))); + (encoder).writeInt(((Integer) data.get(272))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(273))); + (encoder).writeInt(((Integer) data.get(274))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(275))); + (encoder).writeInt(((Integer) data.get(276))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(277))); + (encoder).writeInt(((Integer) data.get(278))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(279))); + (encoder).writeInt(((Integer) data.get(280))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(281))); + (encoder).writeInt(((Integer) data.get(282))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(283))); + (encoder).writeInt(((Integer) data.get(284))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(285))); + (encoder).writeInt(((Integer) data.get(286))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(287))); + (encoder).writeInt(((Integer) data.get(288))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(289))); + (encoder).writeInt(((Integer) data.get(290))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(291))); + (encoder).writeInt(((Integer) data.get(292))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(293))); + (encoder).writeInt(((Integer) data.get(294))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(295))); + (encoder).writeInt(((Integer) data.get(296))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(297))); + (encoder).writeInt(((Integer) data.get(298))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(299))); + (encoder).writeInt(((Integer) data.get(300))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(301))); + (encoder).writeInt(((Integer) data.get(302))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(303))); + (encoder).writeInt(((Integer) data.get(304))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(305))); + (encoder).writeInt(((Integer) data.get(306))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(307))); + (encoder).writeInt(((Integer) data.get(308))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(309))); + (encoder).writeInt(((Integer) data.get(310))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(311))); + (encoder).writeInt(((Integer) data.get(312))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(313))); + (encoder).writeInt(((Integer) data.get(314))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(315))); + (encoder).writeInt(((Integer) data.get(316))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(317))); + (encoder).writeInt(((Integer) data.get(318))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(319))); + (encoder).writeInt(((Integer) data.get(320))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(321))); + (encoder).writeInt(((Integer) data.get(322))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(323))); + (encoder).writeInt(((Integer) data.get(324))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(325))); + (encoder).writeInt(((Integer) data.get(326))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(327))); + (encoder).writeInt(((Integer) data.get(328))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(329))); + (encoder).writeInt(((Integer) data.get(330))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(331))); + (encoder).writeInt(((Integer) data.get(332))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(333))); + (encoder).writeInt(((Integer) data.get(334))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(335))); + (encoder).writeInt(((Integer) data.get(336))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(337))); + (encoder).writeInt(((Integer) data.get(338))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(339))); + (encoder).writeInt(((Integer) data.get(340))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(341))); + (encoder).writeInt(((Integer) data.get(342))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(343))); + (encoder).writeInt(((Integer) data.get(344))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(345))); + (encoder).writeInt(((Integer) data.get(346))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(347))); + (encoder).writeInt(((Integer) data.get(348))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(349))); + (encoder).writeInt(((Integer) data.get(350))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(351))); + (encoder).writeInt(((Integer) data.get(352))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(353))); + (encoder).writeInt(((Integer) data.get(354))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(355))); + (encoder).writeInt(((Integer) data.get(356))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(357))); + (encoder).writeInt(((Integer) data.get(358))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(359))); + (encoder).writeInt(((Integer) data.get(360))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(361))); + (encoder).writeInt(((Integer) data.get(362))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(363))); + (encoder).writeInt(((Integer) data.get(364))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(365))); + (encoder).writeInt(((Integer) data.get(366))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(367))); + (encoder).writeInt(((Integer) data.get(368))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(369))); + (encoder).writeInt(((Integer) data.get(370))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(371))); + (encoder).writeInt(((Integer) data.get(372))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(373))); + (encoder).writeInt(((Integer) data.get(374))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(375))); + (encoder).writeInt(((Integer) data.get(376))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(377))); + (encoder).writeInt(((Integer) data.get(378))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(379))); + (encoder).writeInt(((Integer) data.get(380))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(381))); + (encoder).writeInt(((Integer) data.get(382))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(383))); + (encoder).writeInt(((Integer) data.get(384))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(385))); + (encoder).writeInt(((Integer) data.get(386))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(387))); + (encoder).writeInt(((Integer) data.get(388))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(389))); + (encoder).writeInt(((Integer) data.get(390))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(391))); + (encoder).writeInt(((Integer) data.get(392))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(393))); + (encoder).writeInt(((Integer) data.get(394))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(395))); + (encoder).writeInt(((Integer) data.get(396))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(397))); + (encoder).writeInt(((Integer) data.get(398))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(399))); + (encoder).writeInt(((Integer) data.get(400))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(401))); + (encoder).writeInt(((Integer) data.get(402))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(403))); + (encoder).writeInt(((Integer) data.get(404))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(405))); + (encoder).writeInt(((Integer) data.get(406))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(407))); + (encoder).writeInt(((Integer) data.get(408))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(409))); + (encoder).writeInt(((Integer) data.get(410))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(411))); + (encoder).writeInt(((Integer) data.get(412))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(413))); + (encoder).writeInt(((Integer) data.get(414))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(415))); + (encoder).writeInt(((Integer) data.get(416))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(417))); + (encoder).writeInt(((Integer) data.get(418))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(419))); + (encoder).writeInt(((Integer) data.get(420))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(421))); + (encoder).writeInt(((Integer) data.get(422))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(423))); + (encoder).writeInt(((Integer) data.get(424))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(425))); + (encoder).writeInt(((Integer) data.get(426))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(427))); + (encoder).writeInt(((Integer) data.get(428))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(429))); + (encoder).writeInt(((Integer) data.get(430))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(431))); + (encoder).writeInt(((Integer) data.get(432))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(433))); + (encoder).writeInt(((Integer) data.get(434))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(435))); + (encoder).writeInt(((Integer) data.get(436))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(437))); + (encoder).writeInt(((Integer) data.get(438))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(439))); + (encoder).writeInt(((Integer) data.get(440))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(441))); + (encoder).writeInt(((Integer) data.get(442))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(443))); + (encoder).writeInt(((Integer) data.get(444))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(445))); + (encoder).writeInt(((Integer) data.get(446))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(447))); + (encoder).writeInt(((Integer) data.get(448))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(449))); + (encoder).writeInt(((Integer) data.get(450))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(451))); + (encoder).writeInt(((Integer) data.get(452))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(453))); + (encoder).writeInt(((Integer) data.get(454))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(455))); + (encoder).writeInt(((Integer) data.get(456))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(457))); + (encoder).writeInt(((Integer) data.get(458))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(459))); + (encoder).writeInt(((Integer) data.get(460))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(461))); + (encoder).writeInt(((Integer) data.get(462))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(463))); + (encoder).writeInt(((Integer) data.get(464))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(465))); + (encoder).writeInt(((Integer) data.get(466))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(467))); + (encoder).writeInt(((Integer) data.get(468))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(469))); + (encoder).writeInt(((Integer) data.get(470))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(471))); + (encoder).writeInt(((Integer) data.get(472))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(473))); + (encoder).writeInt(((Integer) data.get(474))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(475))); + (encoder).writeInt(((Integer) data.get(476))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(477))); + (encoder).writeInt(((Integer) data.get(478))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(479))); + (encoder).writeInt(((Integer) data.get(480))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(481))); + (encoder).writeInt(((Integer) data.get(482))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(483))); + (encoder).writeInt(((Integer) data.get(484))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(485))); + (encoder).writeInt(((Integer) data.get(486))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(487))); + (encoder).writeInt(((Integer) data.get(488))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(489))); + (encoder).writeInt(((Integer) data.get(490))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(491))); + (encoder).writeInt(((Integer) data.get(492))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(493))); + (encoder).writeInt(((Integer) data.get(494))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(495))); + (encoder).writeInt(((Integer) data.get(496))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(497))); + (encoder).writeInt(((Integer) data.get(498))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(499))); + (encoder).writeInt(((Integer) data.get(500))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(501))); + (encoder).writeInt(((Integer) data.get(502))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(503))); + (encoder).writeInt(((Integer) data.get(504))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(505))); + (encoder).writeInt(((Integer) data.get(506))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(507))); + (encoder).writeInt(((Integer) data.get(508))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(509))); + (encoder).writeInt(((Integer) data.get(510))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(511))); + (encoder).writeInt(((Integer) data.get(512))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(513))); + (encoder).writeInt(((Integer) data.get(514))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(515))); + (encoder).writeInt(((Integer) data.get(516))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(517))); + (encoder).writeInt(((Integer) data.get(518))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(519))); + (encoder).writeInt(((Integer) data.get(520))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(521))); + (encoder).writeInt(((Integer) data.get(522))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(523))); + (encoder).writeInt(((Integer) data.get(524))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(525))); + (encoder).writeInt(((Integer) data.get(526))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(527))); + (encoder).writeInt(((Integer) data.get(528))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(529))); + (encoder).writeInt(((Integer) data.get(530))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(531))); + (encoder).writeInt(((Integer) data.get(532))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(533))); + (encoder).writeInt(((Integer) data.get(534))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(535))); + (encoder).writeInt(((Integer) data.get(536))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(537))); + (encoder).writeInt(((Integer) data.get(538))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(539))); + (encoder).writeInt(((Integer) data.get(540))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(541))); + (encoder).writeInt(((Integer) data.get(542))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(543))); + (encoder).writeInt(((Integer) data.get(544))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(545))); + (encoder).writeInt(((Integer) data.get(546))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(547))); + (encoder).writeInt(((Integer) data.get(548))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(549))); + (encoder).writeInt(((Integer) data.get(550))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(551))); + (encoder).writeInt(((Integer) data.get(552))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(553))); + (encoder).writeInt(((Integer) data.get(554))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(555))); + (encoder).writeInt(((Integer) data.get(556))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(557))); + (encoder).writeInt(((Integer) data.get(558))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(559))); + (encoder).writeInt(((Integer) data.get(560))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(561))); + (encoder).writeInt(((Integer) data.get(562))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(563))); + (encoder).writeInt(((Integer) data.get(564))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(565))); + (encoder).writeInt(((Integer) data.get(566))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(567))); + (encoder).writeInt(((Integer) data.get(568))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(569))); + (encoder).writeInt(((Integer) data.get(570))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(571))); + (encoder).writeInt(((Integer) data.get(572))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(573))); + (encoder).writeInt(((Integer) data.get(574))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(575))); + (encoder).writeInt(((Integer) data.get(576))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(577))); + (encoder).writeInt(((Integer) data.get(578))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(579))); + (encoder).writeInt(((Integer) data.get(580))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(581))); + (encoder).writeInt(((Integer) data.get(582))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(583))); + (encoder).writeInt(((Integer) data.get(584))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(585))); + (encoder).writeInt(((Integer) data.get(586))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(587))); + (encoder).writeInt(((Integer) data.get(588))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(589))); + (encoder).writeInt(((Integer) data.get(590))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(591))); + (encoder).writeInt(((Integer) data.get(592))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(593))); + (encoder).writeInt(((Integer) data.get(594))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(595))); + (encoder).writeInt(((Integer) data.get(596))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(597))); + (encoder).writeInt(((Integer) data.get(598))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(599))); + (encoder).writeInt(((Integer) data.get(600))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(601))); + (encoder).writeInt(((Integer) data.get(602))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(603))); + (encoder).writeInt(((Integer) data.get(604))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(605))); + (encoder).writeInt(((Integer) data.get(606))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(607))); + (encoder).writeInt(((Integer) data.get(608))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(609))); + (encoder).writeInt(((Integer) data.get(610))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(611))); + (encoder).writeInt(((Integer) data.get(612))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(613))); + (encoder).writeInt(((Integer) data.get(614))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(615))); + (encoder).writeInt(((Integer) data.get(616))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(617))); + (encoder).writeInt(((Integer) data.get(618))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(619))); + (encoder).writeInt(((Integer) data.get(620))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(621))); + (encoder).writeInt(((Integer) data.get(622))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(623))); + (encoder).writeInt(((Integer) data.get(624))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(625))); + (encoder).writeInt(((Integer) data.get(626))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(627))); + (encoder).writeInt(((Integer) data.get(628))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(629))); + (encoder).writeInt(((Integer) data.get(630))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(631))); + (encoder).writeInt(((Integer) data.get(632))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(633))); + (encoder).writeInt(((Integer) data.get(634))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(635))); + (encoder).writeInt(((Integer) data.get(636))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(637))); + (encoder).writeInt(((Integer) data.get(638))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(639))); + (encoder).writeInt(((Integer) data.get(640))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(641))); + (encoder).writeInt(((Integer) data.get(642))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(643))); + (encoder).writeInt(((Integer) data.get(644))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(645))); + (encoder).writeInt(((Integer) data.get(646))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(647))); + (encoder).writeInt(((Integer) data.get(648))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(649))); + (encoder).writeInt(((Integer) data.get(650))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(651))); + (encoder).writeInt(((Integer) data.get(652))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(653))); + (encoder).writeInt(((Integer) data.get(654))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(655))); + (encoder).writeInt(((Integer) data.get(656))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(657))); + (encoder).writeInt(((Integer) data.get(658))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(659))); + (encoder).writeInt(((Integer) data.get(660))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(661))); + (encoder).writeInt(((Integer) data.get(662))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(663))); + (encoder).writeInt(((Integer) data.get(664))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(665))); + (encoder).writeInt(((Integer) data.get(666))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(667))); + (encoder).writeInt(((Integer) data.get(668))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(669))); + (encoder).writeInt(((Integer) data.get(670))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(671))); + (encoder).writeInt(((Integer) data.get(672))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(673))); + (encoder).writeInt(((Integer) data.get(674))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(675))); + (encoder).writeInt(((Integer) data.get(676))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(677))); + (encoder).writeInt(((Integer) data.get(678))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(679))); + (encoder).writeInt(((Integer) data.get(680))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(681))); + (encoder).writeInt(((Integer) data.get(682))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(683))); + (encoder).writeInt(((Integer) data.get(684))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(685))); + (encoder).writeInt(((Integer) data.get(686))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(687))); + (encoder).writeInt(((Integer) data.get(688))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(689))); + (encoder).writeInt(((Integer) data.get(690))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(691))); + (encoder).writeInt(((Integer) data.get(692))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(693))); + (encoder).writeInt(((Integer) data.get(694))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(695))); + (encoder).writeInt(((Integer) data.get(696))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(697))); + (encoder).writeInt(((Integer) data.get(698))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(699))); + (encoder).writeInt(((Integer) data.get(700))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(701))); + (encoder).writeInt(((Integer) data.get(702))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(703))); + (encoder).writeInt(((Integer) data.get(704))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(705))); + (encoder).writeInt(((Integer) data.get(706))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(707))); + (encoder).writeInt(((Integer) data.get(708))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(709))); + (encoder).writeInt(((Integer) data.get(710))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(711))); + (encoder).writeInt(((Integer) data.get(712))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(713))); + (encoder).writeInt(((Integer) data.get(714))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(715))); + (encoder).writeInt(((Integer) data.get(716))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(717))); + (encoder).writeInt(((Integer) data.get(718))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(719))); + (encoder).writeInt(((Integer) data.get(720))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(721))); + (encoder).writeInt(((Integer) data.get(722))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(723))); + (encoder).writeInt(((Integer) data.get(724))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(725))); + (encoder).writeInt(((Integer) data.get(726))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(727))); + (encoder).writeInt(((Integer) data.get(728))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(729))); + (encoder).writeInt(((Integer) data.get(730))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(731))); + (encoder).writeInt(((Integer) data.get(732))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(733))); + (encoder).writeInt(((Integer) data.get(734))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(735))); + (encoder).writeInt(((Integer) data.get(736))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(737))); + (encoder).writeInt(((Integer) data.get(738))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(739))); + (encoder).writeInt(((Integer) data.get(740))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(741))); + (encoder).writeInt(((Integer) data.get(742))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(743))); + (encoder).writeInt(((Integer) data.get(744))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(745))); + (encoder).writeInt(((Integer) data.get(746))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(747))); + (encoder).writeInt(((Integer) data.get(748))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(749))); + (encoder).writeInt(((Integer) data.get(750))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(751))); + (encoder).writeInt(((Integer) data.get(752))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(753))); + (encoder).writeInt(((Integer) data.get(754))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(755))); + (encoder).writeInt(((Integer) data.get(756))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(757))); + (encoder).writeInt(((Integer) data.get(758))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(759))); + (encoder).writeInt(((Integer) data.get(760))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(761))); + (encoder).writeInt(((Integer) data.get(762))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(763))); + (encoder).writeInt(((Integer) data.get(764))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(765))); + (encoder).writeInt(((Integer) data.get(766))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(767))); + (encoder).writeInt(((Integer) data.get(768))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(769))); + (encoder).writeInt(((Integer) data.get(770))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(771))); + (encoder).writeInt(((Integer) data.get(772))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(773))); + (encoder).writeInt(((Integer) data.get(774))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(775))); + (encoder).writeInt(((Integer) data.get(776))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(777))); + (encoder).writeInt(((Integer) data.get(778))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(779))); + (encoder).writeInt(((Integer) data.get(780))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(781))); + (encoder).writeInt(((Integer) data.get(782))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(783))); + (encoder).writeInt(((Integer) data.get(784))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(785))); + (encoder).writeInt(((Integer) data.get(786))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(787))); + (encoder).writeInt(((Integer) data.get(788))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(789))); + (encoder).writeInt(((Integer) data.get(790))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(791))); + (encoder).writeInt(((Integer) data.get(792))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(793))); + (encoder).writeInt(((Integer) data.get(794))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(795))); + (encoder).writeInt(((Integer) data.get(796))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(797))); + (encoder).writeInt(((Integer) data.get(798))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(799))); + (encoder).writeInt(((Integer) data.get(800))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(801))); + (encoder).writeInt(((Integer) data.get(802))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(803))); + (encoder).writeInt(((Integer) data.get(804))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(805))); + (encoder).writeInt(((Integer) data.get(806))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(807))); + (encoder).writeInt(((Integer) data.get(808))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(809))); + (encoder).writeInt(((Integer) data.get(810))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(811))); + (encoder).writeInt(((Integer) data.get(812))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(813))); + (encoder).writeInt(((Integer) data.get(814))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(815))); + (encoder).writeInt(((Integer) data.get(816))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(817))); + (encoder).writeInt(((Integer) data.get(818))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(819))); + (encoder).writeInt(((Integer) data.get(820))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(821))); + (encoder).writeInt(((Integer) data.get(822))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(823))); + (encoder).writeInt(((Integer) data.get(824))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(825))); + (encoder).writeInt(((Integer) data.get(826))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(827))); + (encoder).writeInt(((Integer) data.get(828))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(829))); + (encoder).writeInt(((Integer) data.get(830))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(831))); + (encoder).writeInt(((Integer) data.get(832))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(833))); + (encoder).writeInt(((Integer) data.get(834))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(835))); + (encoder).writeInt(((Integer) data.get(836))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(837))); + (encoder).writeInt(((Integer) data.get(838))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(839))); + (encoder).writeInt(((Integer) data.get(840))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(841))); + (encoder).writeInt(((Integer) data.get(842))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(843))); + (encoder).writeInt(((Integer) data.get(844))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(845))); + (encoder).writeInt(((Integer) data.get(846))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(847))); + (encoder).writeInt(((Integer) data.get(848))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(849))); + (encoder).writeInt(((Integer) data.get(850))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(851))); + (encoder).writeInt(((Integer) data.get(852))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(853))); + (encoder).writeInt(((Integer) data.get(854))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(855))); + (encoder).writeInt(((Integer) data.get(856))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(857))); + (encoder).writeInt(((Integer) data.get(858))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(859))); + (encoder).writeInt(((Integer) data.get(860))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(861))); + (encoder).writeInt(((Integer) data.get(862))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(863))); + (encoder).writeInt(((Integer) data.get(864))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(865))); + (encoder).writeInt(((Integer) data.get(866))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(867))); + (encoder).writeInt(((Integer) data.get(868))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(869))); + (encoder).writeInt(((Integer) data.get(870))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(871))); + (encoder).writeInt(((Integer) data.get(872))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(873))); + (encoder).writeInt(((Integer) data.get(874))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(875))); + (encoder).writeInt(((Integer) data.get(876))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(877))); + (encoder).writeInt(((Integer) data.get(878))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(879))); + (encoder).writeInt(((Integer) data.get(880))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(881))); + (encoder).writeInt(((Integer) data.get(882))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(883))); + (encoder).writeInt(((Integer) data.get(884))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(885))); + (encoder).writeInt(((Integer) data.get(886))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(887))); + (encoder).writeInt(((Integer) data.get(888))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(889))); + (encoder).writeInt(((Integer) data.get(890))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(891))); + (encoder).writeInt(((Integer) data.get(892))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(893))); + (encoder).writeInt(((Integer) data.get(894))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(895))); + (encoder).writeInt(((Integer) data.get(896))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(897))); + (encoder).writeInt(((Integer) data.get(898))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(899))); + (encoder).writeInt(((Integer) data.get(900))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(901))); + (encoder).writeInt(((Integer) data.get(902))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(903))); + (encoder).writeInt(((Integer) data.get(904))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(905))); + (encoder).writeInt(((Integer) data.get(906))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(907))); + (encoder).writeInt(((Integer) data.get(908))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(909))); + (encoder).writeInt(((Integer) data.get(910))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(911))); + (encoder).writeInt(((Integer) data.get(912))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(913))); + (encoder).writeInt(((Integer) data.get(914))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(915))); + (encoder).writeInt(((Integer) data.get(916))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(917))); + (encoder).writeInt(((Integer) data.get(918))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(919))); + (encoder).writeInt(((Integer) data.get(920))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(921))); + (encoder).writeInt(((Integer) data.get(922))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(923))); + (encoder).writeInt(((Integer) data.get(924))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(925))); + (encoder).writeInt(((Integer) data.get(926))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(927))); + (encoder).writeInt(((Integer) data.get(928))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(929))); + (encoder).writeInt(((Integer) data.get(930))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(931))); + (encoder).writeInt(((Integer) data.get(932))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(933))); + (encoder).writeInt(((Integer) data.get(934))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(935))); + (encoder).writeInt(((Integer) data.get(936))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(937))); + (encoder).writeInt(((Integer) data.get(938))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(939))); + (encoder).writeInt(((Integer) data.get(940))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(941))); + (encoder).writeInt(((Integer) data.get(942))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(943))); + (encoder).writeInt(((Integer) data.get(944))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(945))); + (encoder).writeInt(((Integer) data.get(946))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(947))); + (encoder).writeInt(((Integer) data.get(948))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(949))); + (encoder).writeInt(((Integer) data.get(950))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(951))); + (encoder).writeInt(((Integer) data.get(952))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(953))); + (encoder).writeInt(((Integer) data.get(954))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(955))); + (encoder).writeInt(((Integer) data.get(956))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(957))); + (encoder).writeInt(((Integer) data.get(958))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(959))); + (encoder).writeInt(((Integer) data.get(960))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(961))); + (encoder).writeInt(((Integer) data.get(962))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(963))); + (encoder).writeInt(((Integer) data.get(964))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(965))); + (encoder).writeInt(((Integer) data.get(966))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(967))); + (encoder).writeInt(((Integer) data.get(968))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(969))); + (encoder).writeInt(((Integer) data.get(970))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(971))); + (encoder).writeInt(((Integer) data.get(972))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(973))); + (encoder).writeInt(((Integer) data.get(974))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(975))); + (encoder).writeInt(((Integer) data.get(976))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(977))); + (encoder).writeInt(((Integer) data.get(978))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(979))); + (encoder).writeInt(((Integer) data.get(980))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(981))); + (encoder).writeInt(((Integer) data.get(982))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(983))); + (encoder).writeInt(((Integer) data.get(984))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(985))); + (encoder).writeInt(((Integer) data.get(986))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(987))); + (encoder).writeInt(((Integer) data.get(988))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(989))); + (encoder).writeInt(((Integer) data.get(990))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(991))); + (encoder).writeInt(((Integer) data.get(992))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(993))); + (encoder).writeInt(((Integer) data.get(994))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(995))); + (encoder).writeInt(((Integer) data.get(996))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(997))); + (encoder).writeInt(((Integer) data.get(998))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(999))); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java new file mode 100644 index 000000000..4bba3d0c4 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java @@ -0,0 +1,116 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + int valueToWrite0; + Object enumValue0 = data.get(0); + if (enumValue0 instanceof Enum) { + valueToWrite0 = ((Enum) enumValue0).ordinal(); + } else { + valueToWrite0 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).toString()); + } + (encoder).writeEnum(valueToWrite0); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + GenericEnumSymbol testEnumUnion0 = ((GenericEnumSymbol) data.get(1)); + if (testEnumUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((testEnumUnion0 instanceof GenericEnumSymbol)&&"com.linkedin.avro.fastserde.generated.avro.testEnum".equals(((GenericEnumSymbol) testEnumUnion0).getSchema().getFullName())) { + (encoder).writeIndex(1); + int valueToWrite1; + Object enumValue1 = testEnumUnion0; + if (enumValue1 instanceof Enum) { + valueToWrite1 = ((Enum) enumValue1).ordinal(); + } else { + valueToWrite1 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).toString()); + } + (encoder).writeEnum(valueToWrite1); + } + } + List testEnumArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testEnumArray0 == null)||testEnumArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testEnumArray0 .size()); + for (int counter0 = 0; (counter0 testEnumUnionArray0 = ((List ) data.get(3)); + (encoder).writeArrayStart(); + if ((testEnumUnionArray0 == null)||testEnumUnionArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testEnumUnionArray0 .size()); + for (int counter1 = 0; (counter1 ) testEnumUnionArray0).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof GenericEnumSymbol)&&"com.linkedin.avro.fastserde.generated.avro.testEnum".equals(((GenericEnumSymbol) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + int valueToWrite3; + Object enumValue3 = union0; + if (enumValue3 instanceof Enum) { + valueToWrite3 = ((Enum) enumValue3).ordinal(); + } else { + valueToWrite3 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue3).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue3).toString()); + } + (encoder).writeEnum(valueToWrite3); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java new file mode 100644 index 000000000..fbf0fc85b --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java @@ -0,0 +1,88 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + GenericFixed testFixedUnion0 = ((GenericFixed) data.get(1)); + if (testFixedUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((testFixedUnion0 instanceof GenericFixed)&&"com.linkedin.avro.fastserde.generated.avro.testFixed".equals(((GenericFixed) testFixedUnion0).getSchema().getFullName())) { + (encoder).writeIndex(1); + (encoder).writeFixed(((GenericFixed) testFixedUnion0).bytes()); + } + } + List testFixedArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testFixedArray0 == null)||testFixedArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testFixedArray0 .size()); + for (int counter0 = 0; (counter0 testFixedUnionArray0 = ((List ) data.get(3)); + (encoder).writeArrayStart(); + if ((testFixedUnionArray0 == null)||testFixedUnionArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testFixedUnionArray0 .size()); + for (int counter1 = 0; (counter1 ) testFixedUnionArray0).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof GenericFixed)&&"com.linkedin.avro.fastserde.generated.avro.testFixed".equals(((GenericFixed) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + (encoder).writeFixed(((GenericFixed) union0).bytes()); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java new file mode 100644 index 000000000..b03f954b2 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java @@ -0,0 +1,70 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object union0 = ((Object) data.get(0)); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } else { + if (union0 instanceof CharSequence) { + (encoder).writeIndex(2); + if (((CharSequence) union0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) union0))); + } else { + (encoder).writeString(((CharSequence) union0).toString()); + } + } else { + if (union0 instanceof Integer) { + (encoder).writeIndex(3); + (encoder).writeInt(((Integer) union0)); + } + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java new file mode 100644 index 000000000..7d1c06f6c --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java @@ -0,0 +1,157 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.nio.ByteBuffer; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Integer testIntUnion0 = ((Integer) data.get(1)); + if (testIntUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeInt(((Integer) testIntUnion0)); + } + Integer testFlippedIntUnion0 = ((Integer) data.get(2)); + if (testFlippedIntUnion0 == null) { + (encoder).writeIndex(1); + (encoder).writeNull(); + } else { + (encoder).writeIndex(0); + (encoder).writeInt(((Integer) testFlippedIntUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(3)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(3)))); + } else { + (encoder).writeString(((CharSequence) data.get(3)).toString()); + } + CharSequence testStringUnion0 = ((CharSequence) data.get(4)); + if (testStringUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testStringUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringUnion0))); + } else { + (encoder).writeString(((CharSequence) testStringUnion0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeLong(((Long) data.get(5))); + Long testLongUnion0 = ((Long) data.get(6)); + if (testLongUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeLong(((Long) testLongUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeDouble(((Double) data.get(7))); + Double testDoubleUnion0 = ((Double) data.get(8)); + if (testDoubleUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeDouble(((Double) testDoubleUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFloat(((Float) data.get(9))); + Float testFloatUnion0 = ((Float) data.get(10)); + if (testFloatUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeFloat(((Float) testFloatUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeBoolean(((Boolean) data.get(11))); + Boolean testBooleanUnion0 = ((Boolean) data.get(12)); + if (testBooleanUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeBoolean(((Boolean) testBooleanUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeBytes(((ByteBuffer) data.get(13))); + ByteBuffer testBytesUnion0 = ((ByteBuffer) data.get(14)); + if (testBytesUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeBytes(((ByteBuffer) testBytesUnion0)); + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java new file mode 100644 index 000000000..dd4264616 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object union_field0 = ((Object) data.get(0)); + if (union_field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record1".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord10(((IndexedRecord) union_field0), (encoder), (customization)); + } else { + if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record2".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { + (encoder).writeIndex(2); + serializeRecord20(((IndexedRecord) union_field0), (encoder), (customization)); + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + } + + @SuppressWarnings("unchecked") + public void serializeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java new file mode 100644 index 000000000..f15d4ab0c --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java @@ -0,0 +1,158 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List recordsArray0 = ((List ) data.get(0)); + (encoder).writeArrayStart(); + if ((recordsArray0 == null)||recordsArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsArray0 .size()); + for (int counter0 = 0; (counter0 ) recordsArray0).get(counter0); + serializeSubRecord0(subRecord0, (encoder), (customization)); + } + } + (encoder).writeArrayEnd(); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map recordsMap0 = ((Map ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMap0); + } + (encoder).writeMapStart(); + if ((recordsMap0 == null)||recordsMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsMap0 .size()); + for (CharSequence key0 : ((Map ) recordsMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord subRecord1 = null; + subRecord1 = ((Map ) recordsMap0).get(key0); + serializeSubRecord0(subRecord1, (encoder), (customization)); + } + } + (encoder).writeMapEnd(); + List recordsArrayUnion0 = ((List ) data.get(2)); + if (recordsArrayUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsArrayUnion0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) recordsArrayUnion0) == null)||((List ) recordsArrayUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) recordsArrayUnion0).size()); + for (int counter1 = 0; (counter1 <((List ) recordsArrayUnion0).size()); counter1 ++) { + (encoder).startItem(); + IndexedRecord union0 = null; + union0 = ((List )((List ) recordsArrayUnion0)).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map recordsMapUnion0 = ((Map ) data.get(3)); + if (recordsMapUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsMapUnion0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map ) recordsMapUnion0)); + } + (encoder).writeMapStart(); + if ((((Map ) recordsMapUnion0) == null)||((Map ) recordsMapUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map ) recordsMapUnion0).size()); + for (CharSequence key1 : ((Map )((Map ) recordsMapUnion0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + IndexedRecord union1 = null; + union1 = ((Map )((Map ) recordsMapUnion0)).get(key1); + if (union1 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java new file mode 100644 index 000000000..181f90dd5 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java @@ -0,0 +1,230 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List> recordsArrayMap0 = ((List> ) data.get(0)); + (encoder).writeArrayStart(); + if ((recordsArrayMap0 == null)||recordsArrayMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsArrayMap0 .size()); + for (int counter0 = 0; (counter0 map0 = null; + map0 = ((List> ) recordsArrayMap0).get(counter0); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map0); + } + (encoder).writeMapStart(); + if ((map0 == null)||map0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(map0 .size()); + for (CharSequence key0 : ((Map ) map0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord union0 = null; + union0 = ((Map ) map0).get(key0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + (encoder).writeArrayEnd(); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map> recordsMapArray0 = ((Map> ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMapArray0); + } + (encoder).writeMapStart(); + if ((recordsMapArray0 == null)||recordsMapArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsMapArray0 .size()); + for (CharSequence key1 : ((Map> ) recordsMapArray0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + List array0 = null; + array0 = ((Map> ) recordsMapArray0).get(key1); + (encoder).writeArrayStart(); + if ((array0 == null)||array0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array0 .size()); + for (int counter1 = 0; (counter1 ) array0).get(counter1); + if (union1 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + (encoder).writeMapEnd(); + List> recordsArrayMapUnion0 = ((List> ) data.get(2)); + if (recordsArrayMapUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsArrayMapUnion0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List> ) recordsArrayMapUnion0) == null)||((List> ) recordsArrayMapUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List> ) recordsArrayMapUnion0).size()); + for (int counter2 = 0; (counter2 <((List> ) recordsArrayMapUnion0).size()); counter2 ++) { + (encoder).startItem(); + Map map1 = null; + map1 = ((List> )((List> ) recordsArrayMapUnion0)).get(counter2); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map1); + } + (encoder).writeMapStart(); + if ((map1 == null)||map1 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(map1 .size()); + for (CharSequence key2 : ((Map ) map1).keySet()) { + (encoder).startItem(); + (encoder).writeString(key2); + IndexedRecord union2 = null; + union2 = ((Map ) map1).get(key2); + if (union2 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union2 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union2).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union2), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + (encoder).writeArrayEnd(); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map> recordsMapArrayUnion0 = ((Map> ) data.get(3)); + if (recordsMapArrayUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsMapArrayUnion0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map> ) recordsMapArrayUnion0)); + } + (encoder).writeMapStart(); + if ((((Map> ) recordsMapArrayUnion0) == null)||((Map> ) recordsMapArrayUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map> ) recordsMapArrayUnion0).size()); + for (CharSequence key3 : ((Map> )((Map> ) recordsMapArrayUnion0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key3); + List array1 = null; + array1 = ((Map> )((Map> ) recordsMapArrayUnion0)).get(key3); + (encoder).writeArrayStart(); + if ((array1 == null)||array1 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array1 .size()); + for (int counter3 = 0; (counter3 ) array1).get(counter3); + if (union3 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union3 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union3).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union3), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + (encoder).writeMapEnd(); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java new file mode 100644 index 000000000..0b99918cf --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + IndexedRecord record0 = ((IndexedRecord) data.get(0)); + if (record0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((record0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) record0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) record0), (encoder), (customization)); + } + } + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + IndexedRecord record10 = ((IndexedRecord) data.get(1)); + serializeSubRecord0(record10, (encoder), (customization)); + CharSequence field0 = ((CharSequence) data.get(2)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeEnums_GenericSerializer_957378572.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeEnums_GenericSerializer_957378572.java new file mode 100644 index 000000000..a706cb4aa --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeEnums_GenericSerializer_957378572.java @@ -0,0 +1,95 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeEnums_GenericSerializer_957378572 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + int valueToWrite0; + Object enumValue0 = data.get(0); + if (enumValue0 instanceof Enum) { + valueToWrite0 = ((Enum) enumValue0).ordinal(); + } else { + valueToWrite0 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).toString()); + } + (encoder).writeEnum(valueToWrite0); + serialize_FastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List arrayOfEnums0 = ((List ) data.get(1)); + if (arrayOfEnums0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (arrayOfEnums0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) arrayOfEnums0) == null)||((List ) arrayOfEnums0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) arrayOfEnums0).size()); + for (int counter0 = 0; (counter0 <((List ) arrayOfEnums0).size()); counter0 ++) { + (encoder).startItem(); + int valueToWrite1; + Object enumValue1 = ((List ) arrayOfEnums0).get(counter0); + if (enumValue1 instanceof Enum) { + valueToWrite1 = ((Enum) enumValue1).ordinal(); + } else { + valueToWrite1 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).toString()); + } + (encoder).writeEnum(valueToWrite1); + } + } + (encoder).writeArrayEnd(); + } + } + Map mapOfEnums0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfEnums0); + } + (encoder).writeMapStart(); + if ((mapOfEnums0 == null)||mapOfEnums0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfEnums0 .size()); + for (CharSequence key0 : ((Map ) mapOfEnums0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + int valueToWrite2; + Object enumValue2 = mapOfEnums0 .get(key0); + if (enumValue2 instanceof Enum) { + valueToWrite2 = ((Enum) enumValue2).ordinal(); + } else { + valueToWrite2 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue2).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue2).toString()); + } + (encoder).writeEnum(valueToWrite2); + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeFixed_GenericSerializer_504108934.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeFixed_GenericSerializer_504108934.java new file mode 100644 index 000000000..225d212cf --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeFixed_GenericSerializer_504108934.java @@ -0,0 +1,74 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeFixed_GenericSerializer_504108934 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List arrayOfFixed0 = ((List ) data.get(1)); + if (arrayOfFixed0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (arrayOfFixed0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) arrayOfFixed0) == null)||((List ) arrayOfFixed0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) arrayOfFixed0).size()); + for (int counter0 = 0; (counter0 <((List ) arrayOfFixed0).size()); counter0 ++) { + (encoder).startItem(); + (encoder).writeFixed(((GenericFixed)((List ) arrayOfFixed0).get(counter0)).bytes()); + } + } + (encoder).writeArrayEnd(); + } + } + Map mapOfFixed0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfFixed0); + } + (encoder).writeMapStart(); + if ((mapOfFixed0 == null)||mapOfFixed0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfFixed0 .size()); + for (CharSequence key0 : ((Map ) mapOfFixed0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + (encoder).writeFixed(((GenericFixed) mapOfFixed0 .get(key0)).bytes()); + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeLogicalTypesDefined_GenericSerializer_229156053.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeLogicalTypesDefined_GenericSerializer_229156053.java new file mode 100644 index 000000000..71d0c0c52 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeLogicalTypesDefined_GenericSerializer_229156053.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.time.Instant; +import java.time.LocalDate; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.Conversions; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeLogicalTypesDefined_GenericSerializer_229156053 + implements FastSerializer +{ + + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesDefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesDefined0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object convertedValue0 = data.get(0); + convertedValue0 = Conversions.convertToRawType(convertedValue0, this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis); + (encoder).writeInt(((Integer) convertedValue0)); + serialize_FastSerdeLogicalTypesDefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesDefined0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object convertedValue1 = data.get(1); + convertedValue1 = Conversions.convertToRawType(convertedValue1, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue1)); + List arrayOfUnionOfDateAndTimestampMillis0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((arrayOfUnionOfDateAndTimestampMillis0 == null)||arrayOfUnionOfDateAndTimestampMillis0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(arrayOfUnionOfDateAndTimestampMillis0 .size()); + for (int counter0 = 0; (counter0 ) arrayOfUnionOfDateAndTimestampMillis0).get(counter0); + if (union0 instanceof LocalDate) { + (encoder).writeIndex(0); + Object convertedValue2 = union0; + convertedValue2 = Conversions.convertToRawType(convertedValue2, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue2)); + } else { + if (union0 instanceof Instant) { + (encoder).writeIndex(1); + Object convertedValue3 = union0; + convertedValue3 = Conversions.convertToRawType(convertedValue3, this.logicalTypeSchema_1074306973, this.logicalTypeSchema_1074306973 .getLogicalType(), this.conversion_timestamp_millis); + (encoder).writeLong(((Long) convertedValue3)); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeLogicalTypesDefined_SpecificSerializer_229156053.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeLogicalTypesDefined_SpecificSerializer_229156053.java new file mode 100644 index 000000000..e1ec41f75 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeLogicalTypesDefined_SpecificSerializer_229156053.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.time.Instant; +import java.time.LocalDate; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined; +import org.apache.avro.Conversions; +import org.apache.avro.Schema; +import org.apache.avro.io.Encoder; + +public class FastSerdeLogicalTypesDefined_SpecificSerializer_229156053 + implements FastSerializer +{ + + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + + public void serialize(FastSerdeLogicalTypesDefined data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesDefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesDefined0(FastSerdeLogicalTypesDefined data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object convertedValue0 = data.get(0); + convertedValue0 = Conversions.convertToRawType(convertedValue0, this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis); + (encoder).writeInt(((Integer) convertedValue0)); + serialize_FastSerdeLogicalTypesDefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesDefined0(FastSerdeLogicalTypesDefined data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object convertedValue1 = data.get(1); + convertedValue1 = Conversions.convertToRawType(convertedValue1, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue1)); + List arrayOfUnionOfDateAndTimestampMillis0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((arrayOfUnionOfDateAndTimestampMillis0 == null)||arrayOfUnionOfDateAndTimestampMillis0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(arrayOfUnionOfDateAndTimestampMillis0 .size()); + for (int counter0 = 0; (counter0 ) arrayOfUnionOfDateAndTimestampMillis0).get(counter0); + if (union0 instanceof LocalDate) { + (encoder).writeIndex(0); + Object convertedValue2 = union0; + convertedValue2 = Conversions.convertToRawType(convertedValue2, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue2)); + } else { + if (union0 instanceof Instant) { + (encoder).writeIndex(1); + Object convertedValue3 = union0; + convertedValue3 = Conversions.convertToRawType(convertedValue3, this.logicalTypeSchema_1074306973, this.logicalTypeSchema_1074306973 .getLogicalType(), this.conversion_timestamp_millis); + (encoder).writeLong(((Long) convertedValue3)); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeLogicalTypesTest1_GenericSerializer_1007574890.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeLogicalTypesTest1_GenericSerializer_1007574890.java new file mode 100644 index 000000000..fcacac81a --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeLogicalTypesTest1_GenericSerializer_1007574890.java @@ -0,0 +1,352 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.math.BigDecimal; +import java.nio.ByteBuffer; +import java.time.Instant; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.Conversions; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastSerdeLogicalTypesTest1_GenericSerializer_1007574890 + implements FastSerializer +{ + + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.LocalTimestampMillisConversion conversion_local_timestamp_millis = new org.apache.avro.data.TimeConversions.LocalTimestampMillisConversion(); + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final Conversions.DecimalConversion conversion_decimal = new Conversions.DecimalConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + private final Schema logicalTypeSchema_120893213 = Schema.parse("{\"type\":\"bytes\",\"logicalType\":\"decimal\",\"precision\":4,\"scale\":2}"); + private final Schema logicalTypeSchema__1252781617 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-micros\"}"); + private final Schema logicalTypeSchema__1515894331 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"time-micros\"}"); + private final Schema logicalTypeSchema__250645780 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"local-timestamp-millis\"}"); + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesTest10(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesTest10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object unionOfArrayAndMap0 = ((Object) data.get(0)); + if (unionOfArrayAndMap0 instanceof List) { + (encoder).writeIndex(0); + (encoder).writeArrayStart(); + if ((((List ) unionOfArrayAndMap0) == null)||((List ) unionOfArrayAndMap0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) unionOfArrayAndMap0).size()); + Object array0 = ((List ) unionOfArrayAndMap0); + if (array0 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList0 = ((PrimitiveIntList) array0); + for (int counter0 = 0; (counter0 ) unionOfArrayAndMap0).size()); counter1 ++) { + (encoder).startItem(); + Object convertedValue1 = ((List ) unionOfArrayAndMap0).get(counter1); + convertedValue1 = Conversions.convertToRawType(convertedValue1, this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis); + (encoder).writeInt(((Integer) convertedValue1)); + } + } + } + (encoder).writeArrayEnd(); + } else { + if (unionOfArrayAndMap0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map ) unionOfArrayAndMap0)); + } + (encoder).writeMapStart(); + if ((((Map ) unionOfArrayAndMap0) == null)||((Map ) unionOfArrayAndMap0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map ) unionOfArrayAndMap0).size()); + for (CharSequence key0 : ((Map )((Map ) unionOfArrayAndMap0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + Object convertedValue2 = ((Map ) unionOfArrayAndMap0).get(key0); + convertedValue2 = Conversions.convertToRawType(convertedValue2, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue2)); + } + } + (encoder).writeMapEnd(); + } + } + serialize_FastSerdeLogicalTypesTest10(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest11(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest12(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest13(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest14(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest15(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesTest10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map mapOfUnionsOfDateAndTimestampMillis0 = ((Map ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfUnionsOfDateAndTimestampMillis0); + } + (encoder).writeMapStart(); + if ((mapOfUnionsOfDateAndTimestampMillis0 == null)||mapOfUnionsOfDateAndTimestampMillis0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfUnionsOfDateAndTimestampMillis0 .size()); + for (CharSequence key1 : ((Map ) mapOfUnionsOfDateAndTimestampMillis0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + Object union0 = null; + union0 = ((Map ) mapOfUnionsOfDateAndTimestampMillis0).get(key1); + if (union0 instanceof LocalDate) { + (encoder).writeIndex(0); + Object convertedValue3 = union0; + convertedValue3 = Conversions.convertToRawType(convertedValue3, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue3)); + } else { + if (union0 instanceof Instant) { + (encoder).writeIndex(1); + Object convertedValue4 = union0; + convertedValue4 = Conversions.convertToRawType(convertedValue4, this.logicalTypeSchema_1074306973, this.logicalTypeSchema_1074306973 .getLogicalType(), this.conversion_timestamp_millis); + (encoder).writeLong(((Long) convertedValue4)); + } + } + } + } + (encoder).writeMapEnd(); + Map timestampMillisMap0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(timestampMillisMap0); + } + (encoder).writeMapStart(); + if ((timestampMillisMap0 == null)||timestampMillisMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(timestampMillisMap0 .size()); + for (CharSequence key2 : ((Map ) timestampMillisMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key2); + Object convertedValue5 = timestampMillisMap0 .get(key2); + convertedValue5 = Conversions.convertToRawType(convertedValue5, this.logicalTypeSchema_1074306973, this.logicalTypeSchema_1074306973 .getLogicalType(), this.conversion_timestamp_millis); + (encoder).writeLong(((Long) convertedValue5)); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesTest11(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List nullableArrayOfDates0 = ((List ) data.get(3)); + if (nullableArrayOfDates0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (nullableArrayOfDates0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) nullableArrayOfDates0) == null)||((List ) nullableArrayOfDates0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) nullableArrayOfDates0).size()); + Object array1 = ((List ) nullableArrayOfDates0); + if (array1 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList1 = ((PrimitiveIntList) array1); + for (int counter2 = 0; (counter2 ) nullableArrayOfDates0).size()); counter3 ++) { + (encoder).startItem(); + Object convertedValue7 = ((List ) nullableArrayOfDates0).get(counter3); + convertedValue7 = Conversions.convertToRawType(convertedValue7, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue7)); + } + } + } + (encoder).writeArrayEnd(); + } + } + List arrayOfDates0 = ((List ) data.get(4)); + (encoder).writeArrayStart(); + if ((arrayOfDates0 == null)||arrayOfDates0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(arrayOfDates0 .size()); + Object array2 = arrayOfDates0; + if (array2 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList2 = ((PrimitiveIntList) array2); + for (int counter4 = 0; (counter4 +{ + + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.LocalTimestampMillisConversion conversion_local_timestamp_millis = new org.apache.avro.data.TimeConversions.LocalTimestampMillisConversion(); + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final Conversions.DecimalConversion conversion_decimal = new Conversions.DecimalConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + private final Schema logicalTypeSchema_120893213 = Schema.parse("{\"type\":\"bytes\",\"logicalType\":\"decimal\",\"precision\":4,\"scale\":2}"); + private final Schema logicalTypeSchema__1252781617 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-micros\"}"); + private final Schema logicalTypeSchema__1515894331 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"time-micros\"}"); + private final Schema logicalTypeSchema__250645780 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"local-timestamp-millis\"}"); + + public void serialize(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesTest10(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesTest10(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object unionOfArrayAndMap0 = ((Object) data.get(0)); + if (unionOfArrayAndMap0 instanceof List) { + (encoder).writeIndex(0); + (encoder).writeArrayStart(); + if ((((List ) unionOfArrayAndMap0) == null)||((List ) unionOfArrayAndMap0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) unionOfArrayAndMap0).size()); + Object array0 = ((List ) unionOfArrayAndMap0); + if (array0 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList0 = ((PrimitiveIntList) array0); + for (int counter0 = 0; (counter0 ) unionOfArrayAndMap0).size()); counter1 ++) { + (encoder).startItem(); + Object convertedValue1 = ((List ) unionOfArrayAndMap0).get(counter1); + convertedValue1 = Conversions.convertToRawType(convertedValue1, this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis); + (encoder).writeInt(((Integer) convertedValue1)); + } + } + } + (encoder).writeArrayEnd(); + } else { + if (unionOfArrayAndMap0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map ) unionOfArrayAndMap0)); + } + (encoder).writeMapStart(); + if ((((Map ) unionOfArrayAndMap0) == null)||((Map ) unionOfArrayAndMap0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map ) unionOfArrayAndMap0).size()); + for (CharSequence key0 : ((Map )((Map ) unionOfArrayAndMap0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + Object convertedValue2 = ((Map ) unionOfArrayAndMap0).get(key0); + convertedValue2 = Conversions.convertToRawType(convertedValue2, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue2)); + } + } + (encoder).writeMapEnd(); + } + } + serialize_FastSerdeLogicalTypesTest10(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest11(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest12(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest13(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest14(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest15(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesTest10(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map mapOfUnionsOfDateAndTimestampMillis0 = ((Map ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfUnionsOfDateAndTimestampMillis0); + } + (encoder).writeMapStart(); + if ((mapOfUnionsOfDateAndTimestampMillis0 == null)||mapOfUnionsOfDateAndTimestampMillis0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfUnionsOfDateAndTimestampMillis0 .size()); + for (CharSequence key1 : ((Map ) mapOfUnionsOfDateAndTimestampMillis0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + Object union0 = null; + union0 = ((Map ) mapOfUnionsOfDateAndTimestampMillis0).get(key1); + if (union0 instanceof LocalDate) { + (encoder).writeIndex(0); + Object convertedValue3 = union0; + convertedValue3 = Conversions.convertToRawType(convertedValue3, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue3)); + } else { + if (union0 instanceof Instant) { + (encoder).writeIndex(1); + Object convertedValue4 = union0; + convertedValue4 = Conversions.convertToRawType(convertedValue4, this.logicalTypeSchema_1074306973, this.logicalTypeSchema_1074306973 .getLogicalType(), this.conversion_timestamp_millis); + (encoder).writeLong(((Long) convertedValue4)); + } + } + } + } + (encoder).writeMapEnd(); + Map timestampMillisMap0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(timestampMillisMap0); + } + (encoder).writeMapStart(); + if ((timestampMillisMap0 == null)||timestampMillisMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(timestampMillisMap0 .size()); + for (CharSequence key2 : ((Map ) timestampMillisMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key2); + Object convertedValue5 = timestampMillisMap0 .get(key2); + convertedValue5 = Conversions.convertToRawType(convertedValue5, this.logicalTypeSchema_1074306973, this.logicalTypeSchema_1074306973 .getLogicalType(), this.conversion_timestamp_millis); + (encoder).writeLong(((Long) convertedValue5)); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesTest11(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List nullableArrayOfDates0 = ((List ) data.get(3)); + if (nullableArrayOfDates0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (nullableArrayOfDates0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) nullableArrayOfDates0) == null)||((List ) nullableArrayOfDates0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) nullableArrayOfDates0).size()); + Object array1 = ((List ) nullableArrayOfDates0); + if (array1 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList1 = ((PrimitiveIntList) array1); + for (int counter2 = 0; (counter2 ) nullableArrayOfDates0).size()); counter3 ++) { + (encoder).startItem(); + Object convertedValue7 = ((List ) nullableArrayOfDates0).get(counter3); + convertedValue7 = Conversions.convertToRawType(convertedValue7, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue7)); + } + } + } + (encoder).writeArrayEnd(); + } + } + List arrayOfDates0 = ((List ) data.get(4)); + (encoder).writeArrayStart(); + if ((arrayOfDates0 == null)||arrayOfDates0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(arrayOfDates0 .size()); + Object array2 = arrayOfDates0; + if (array2 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList2 = ((PrimitiveIntList) array2); + for (int counter4 = 0; (counter4 +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesUndefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesUndefined0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastSerdeLogicalTypesUndefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesUndefined0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(1))); + List arrayOfUnionOfDateAndTimestampMillis0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((arrayOfUnionOfDateAndTimestampMillis0 == null)||arrayOfUnionOfDateAndTimestampMillis0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(arrayOfUnionOfDateAndTimestampMillis0 .size()); + for (int counter0 = 0; (counter0 ) arrayOfUnionOfDateAndTimestampMillis0).get(counter0); + if (union0 instanceof Integer) { + (encoder).writeIndex(0); + (encoder).writeInt(((Integer) union0)); + } else { + if (union0 instanceof Long) { + (encoder).writeIndex(1); + (encoder).writeLong(((Long) union0)); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeLogicalTypesUndefined_SpecificSerializer_1982763418.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeLogicalTypesUndefined_SpecificSerializer_1982763418.java new file mode 100644 index 000000000..ef61b2b5f --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastSerdeLogicalTypesUndefined_SpecificSerializer_1982763418.java @@ -0,0 +1,59 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined; +import org.apache.avro.io.Encoder; + +public class FastSerdeLogicalTypesUndefined_SpecificSerializer_1982763418 + implements FastSerializer +{ + + + public void serialize(FastSerdeLogicalTypesUndefined data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesUndefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesUndefined0(FastSerdeLogicalTypesUndefined data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastSerdeLogicalTypesUndefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesUndefined0(FastSerdeLogicalTypesUndefined data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(1))); + List arrayOfUnionOfDateAndTimestampMillis0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((arrayOfUnionOfDateAndTimestampMillis0 == null)||arrayOfUnionOfDateAndTimestampMillis0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(arrayOfUnionOfDateAndTimestampMillis0 .size()); + for (int counter0 = 0; (counter0 ) arrayOfUnionOfDateAndTimestampMillis0).get(counter0); + if (union0 instanceof Integer) { + (encoder).writeIndex(0); + (encoder).writeInt(((Integer) union0)); + } else { + if (union0 instanceof Long) { + (encoder).writeIndex(1); + (encoder).writeLong(((Long) union0)); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java new file mode 100644 index 000000000..5021c048b --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java @@ -0,0 +1,97 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence testUnionString0 = ((CharSequence) data.get(1)); + if (testUnionString0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testUnionString0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testUnionString0))); + } else { + (encoder).writeString(((CharSequence) testUnionString0).toString()); + } + } + List testStringArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testStringArray0 == null)||testStringArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringArray0 .size()); + for (int counter0 = 0; (counter0 testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } + (encoder).writeMapStart(); + if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringMap0 .size()); + for (CharSequence key0 : ((Map ) testStringMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) testStringMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) testStringMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java new file mode 100644 index 000000000..d09ebd0aa --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java @@ -0,0 +1,97 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_FastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence testUnionString0 = ((CharSequence) data.get(1)); + if (testUnionString0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testUnionString0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testUnionString0))); + } else { + (encoder).writeString(((CharSequence) testUnionString0).toString()); + } + } + List testStringArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testStringArray0 == null)||testStringArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringArray0 .size()); + for (int counter0 = 0; (counter0 testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } + (encoder).writeMapStart(); + if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringMap0 .size()); + for (CharSequence key0 : ((Map ) testStringMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) testStringMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) testStringMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/Map_of_UNION_GenericSerializer_2140000109.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/Map_of_UNION_GenericSerializer_2140000109.java new file mode 100644 index 000000000..22caec46c --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/Map_of_UNION_GenericSerializer_2140000109.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Map_of_UNION_GenericSerializer_2140000109 + implements FastSerializer> +{ + + + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } + (encoder).writeMapStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (CharSequence key0 : ((Map ) data).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord union0 = null; + union0 = ((Map ) data).get(key0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/Map_of_record_GenericSerializer_1677529043.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/Map_of_record_GenericSerializer_1677529043.java new file mode 100644 index 000000000..5c9706891 --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/Map_of_record_GenericSerializer_1677529043.java @@ -0,0 +1,57 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Map_of_record_GenericSerializer_1677529043 + implements FastSerializer> +{ + + + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } + (encoder).writeMapStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (CharSequence key0 : ((Map ) data).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord record0 = null; + record0 = ((Map ) data).get(key0); + serializeRecord0(record0, (encoder), (customization)); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/StringableRecord_SpecificSerializer_842267318.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/StringableRecord_SpecificSerializer_842267318.java new file mode 100644 index 000000000..7e2845f1f --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/StringableRecord_SpecificSerializer_842267318.java @@ -0,0 +1,159 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.File; +import java.io.IOException; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.net.URI; +import java.net.URL; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord; +import com.linkedin.avro.fastserde.generated.avro.StringableRecord; +import com.linkedin.avro.fastserde.generated.avro.StringableSubRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class StringableRecord_SpecificSerializer_842267318 + implements FastSerializer +{ + + + public void serialize(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeStringableRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((BigInteger) data.get(0)).toString()); + serialize_StringableRecord0(data, (encoder), (customization)); + serialize_StringableRecord1(data, (encoder), (customization)); + serialize_StringableRecord2(data, (encoder), (customization)); + serialize_StringableRecord3(data, (encoder), (customization)); + serialize_StringableRecord4(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((BigDecimal) data.get(1)).toString()); + (encoder).writeString(((URI) data.get(2)).toString()); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord1(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((URL) data.get(3)).toString()); + (encoder).writeString(((File) data.get(4)).toString()); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord2(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List urlArray0 = ((List ) data.get(5)); + (encoder).writeArrayStart(); + if ((urlArray0 == null)||urlArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(urlArray0 .size()); + for (int counter0 = 0; (counter0 urlMap0 = ((Map ) data.get(6)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(urlMap0); + } + (encoder).writeMapStart(); + if ((urlMap0 == null)||urlMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(urlMap0 .size()); + for (URL key0 : ((Map ) urlMap0).keySet()) { + (encoder).startItem(); + String keyString0 = key0 .toString(); + (encoder).writeString(keyString0); + (encoder).writeString(((BigInteger) urlMap0 .get(key0)).toString()); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord3(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord0 = ((StringableSubRecord) data.get(7)); + serializeStringableSubRecord0(subRecord0, (encoder), (customization)); + AnotherSubRecord subRecordWithSubRecord0 = ((AnotherSubRecord) data.get(8)); + serializeAnotherSubRecord0(subRecordWithSubRecord0, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((URI) data.get(0)).toString()); + serialize_StringableSubRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object nullStringIntUnion0 = ((Object) data.get(1)); + if (nullStringIntUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (nullStringIntUnion0 instanceof CharSequence) { + (encoder).writeIndex(1); + if (((CharSequence) nullStringIntUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) nullStringIntUnion0))); + } else { + (encoder).writeString(((CharSequence) nullStringIntUnion0).toString()); + } + } else { + if (nullStringIntUnion0 instanceof Integer) { + (encoder).writeIndex(2); + (encoder).writeInt(((Integer) nullStringIntUnion0)); + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeAnotherSubRecord0(AnotherSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord1 = ((StringableSubRecord) data.get(0)); + serializeStringableSubRecord0(subRecord1, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord4(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + String stringUnion0 = ((String) data.get(9)); + if (stringUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeString(((String) stringUnion0).toString()); + } + } + +} diff --git a/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/TestArrayOfFloats_GenericSerializer_1408566797.java b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/TestArrayOfFloats_GenericSerializer_1408566797.java new file mode 100644 index 000000000..1110f191c --- /dev/null +++ b/fastserde/avro-fastserde-tests110/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_10/TestArrayOfFloats_GenericSerializer_1408566797.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_10; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class TestArrayOfFloats_GenericSerializer_1408566797 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeTestArrayOfFloats0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeTestArrayOfFloats0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List array_of_float0 = ((List ) data.get(0)); + (encoder).writeArrayStart(); + if ((array_of_float0 == null)||array_of_float0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array_of_float0 .size()); + Object array0 = array_of_float0; + if (array0 instanceof PrimitiveFloatList) { + PrimitiveFloatList primitiveList0 = ((PrimitiveFloatList) array0); + if (primitiveList0 instanceof BufferBackedPrimitiveFloatList) { + BufferBackedPrimitiveFloatList bufferBackedPrimitiveFloatList = ((BufferBackedPrimitiveFloatList) primitiveList0); + bufferBackedPrimitiveFloatList.writeFloats((encoder)); + } else { + for (int counter0 = 0; (counter0 >>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; import org.apache.avro.Schema; import org.apache.avro.io.Decoder; @@ -19,7 +23,11 @@ public Array_of_BOOLEAN_GenericDeserializer_869749973_869749973(Schema readerSch this.readerSchema = readerSchema; } +<<<<<<< HEAD public List deserialize(List reuse, Decoder decoder) +======= + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveBooleanList array0 = null; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_DOUBLE_GenericDeserializer_18760307_18760307.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_DOUBLE_GenericDeserializer_18760307_18760307.java index 6b6aa1b22..7ee8b9e9f 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_DOUBLE_GenericDeserializer_18760307_18760307.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_DOUBLE_GenericDeserializer_18760307_18760307.java @@ -5,6 +5,10 @@ import java.util.List; import com.linkedin.avro.api.PrimitiveDoubleList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; import org.apache.avro.Schema; import org.apache.avro.io.Decoder; @@ -19,7 +23,11 @@ public Array_of_DOUBLE_GenericDeserializer_18760307_18760307(Schema readerSchema this.readerSchema = readerSchema; } +<<<<<<< HEAD public List deserialize(List reuse, Decoder decoder) +======= + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveDoubleList array0 = null; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_FLOAT_GenericDeserializer_1012670397_1012670397.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_FLOAT_GenericDeserializer_1012670397_1012670397.java index ac047edbc..ed2fd4b04 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_FLOAT_GenericDeserializer_1012670397_1012670397.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_FLOAT_GenericDeserializer_1012670397_1012670397.java @@ -6,6 +6,10 @@ import com.linkedin.avro.api.PrimitiveFloatList; import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.io.Decoder; @@ -19,7 +23,11 @@ public Array_of_FLOAT_GenericDeserializer_1012670397_1012670397(Schema readerSch this.readerSchema = readerSchema; } +<<<<<<< HEAD public List deserialize(List reuse, Decoder decoder) +======= + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveFloatList array0 = null; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_INT_GenericDeserializer_1012089072_1012089072.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_INT_GenericDeserializer_1012089072_1012089072.java index 89a26b958..41506d776 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_INT_GenericDeserializer_1012089072_1012089072.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_INT_GenericDeserializer_1012089072_1012089072.java @@ -5,6 +5,10 @@ import java.util.List; import com.linkedin.avro.api.PrimitiveIntList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; import org.apache.avro.Schema; import org.apache.avro.io.Decoder; @@ -19,7 +23,11 @@ public Array_of_INT_GenericDeserializer_1012089072_1012089072(Schema readerSchem this.readerSchema = readerSchema; } +<<<<<<< HEAD public List deserialize(List reuse, Decoder decoder) +======= + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveIntList array0 = null; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_LONG_GenericDeserializer_325099267_325099267.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_LONG_GenericDeserializer_325099267_325099267.java index 957af2dac..186da0399 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_LONG_GenericDeserializer_325099267_325099267.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_LONG_GenericDeserializer_325099267_325099267.java @@ -5,6 +5,10 @@ import java.util.List; import com.linkedin.avro.api.PrimitiveLongList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; import org.apache.avro.Schema; import org.apache.avro.io.Decoder; @@ -19,7 +23,11 @@ public Array_of_LONG_GenericDeserializer_325099267_325099267(Schema readerSchema this.readerSchema = readerSchema; } +<<<<<<< HEAD public List deserialize(List reuse, Decoder decoder) +======= + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveLongList array0 = null; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_TestRecord_SpecificDeserializer_1088113243_1088113243.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_TestRecord_SpecificDeserializer_1088113243_1088113243.java index 2fa4d28d7..9d4bd1c20 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_TestRecord_SpecificDeserializer_1088113243_1088113243.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_TestRecord_SpecificDeserializer_1088113243_1088113243.java @@ -14,6 +14,10 @@ import com.linkedin.avro.api.PrimitiveLongList; import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.generated.avro.TestEnum; import com.linkedin.avro.fastserde.generated.avro.TestFixed; import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; @@ -37,7 +41,11 @@ public Array_of_TestRecord_SpecificDeserializer_1088113243_1088113243(Schema rea this.readerSchema = readerSchema; } +<<<<<<< HEAD public List deserialize(List reuse, Decoder decoder) +======= + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List array0 = null; @@ -58,14 +66,22 @@ public List deserialize(L if ((reuse) instanceof GenericArray) { arrayArrayElementReuseVar0 = ((GenericArray)(reuse)).peek(); } +<<<<<<< HEAD array0 .add(deserializeTestRecord0(arrayArrayElementReuseVar0, (decoder))); +======= + array0 .add(deserializeTestRecord0(arrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen0 = (decoder.arrayNext()); } return array0; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; @@ -75,6 +91,7 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); } TestRecord.put(0, (decoder.readInt())); +<<<<<<< HEAD populate_TestRecord0((TestRecord), (decoder)); populate_TestRecord1((TestRecord), (decoder)); populate_TestRecord2((TestRecord), (decoder)); @@ -98,6 +115,31 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco } private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -114,7 +156,11 @@ private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(2, (decoder.readLong())); } +<<<<<<< HEAD private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex1 = (decoder.readIndex()); @@ -131,7 +177,11 @@ private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(4, (decoder.readDouble())); } +<<<<<<< HEAD private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex2 = (decoder.readIndex()); @@ -148,7 +198,11 @@ private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(6, (decoder.readFloat())); } +<<<<<<< HEAD private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); @@ -165,7 +219,11 @@ private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(8, (decoder.readBoolean())); } +<<<<<<< HEAD private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex4 = (decoder.readIndex()); @@ -189,7 +247,11 @@ private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(10, byteBuffer0); } +<<<<<<< HEAD private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex5 = (decoder.readIndex()); @@ -220,7 +282,11 @@ private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(12, charSequence0); } +<<<<<<< HEAD private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex6 = (decoder.readIndex()); @@ -254,7 +320,11 @@ private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(14, testFixed1); } +<<<<<<< HEAD private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex7 = (decoder.readIndex()); @@ -314,7 +384,11 @@ private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(16, testFixedArray0); } +<<<<<<< HEAD private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testFixedUnionArray0 = null; @@ -364,7 +438,11 @@ private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(18, Enums.getConstant(TestEnum.class, (decoder.readEnum()))); } +<<<<<<< HEAD private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex9 = (decoder.readIndex()); @@ -400,7 +478,11 @@ private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(20, testEnumArray0); } +<<<<<<< HEAD private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testEnumUnionArray0 = null; @@ -443,14 +525,22 @@ private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(22, null); } else { if (unionIndex11 == 1) { +<<<<<<< HEAD TestRecord.put(22, deserializeSubRecord0(TestRecord.get(22), (decoder))); +======= + TestRecord.put(22, deserializeSubRecord0(TestRecord.get(22), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'subRecordUnion': "+ unionIndex11)); } } } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord; @@ -477,11 +567,19 @@ public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex12)); } } +<<<<<<< HEAD populate_SubRecord0((SubRecord), (decoder)); return SubRecord; } private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord, Decoder decoder) +======= + populate_SubRecord0((SubRecord), (customization), (decoder)); + return SubRecord; + } + + private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex13 = (decoder.readIndex()); @@ -504,10 +602,17 @@ private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubR } } +<<<<<<< HEAD private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) throws IOException { TestRecord.put(23, deserializeSubRecord0(TestRecord.get(23), (decoder))); +======= + private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + TestRecord.put(23, deserializeSubRecord0(TestRecord.get(23), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) List recordsArray0 = null; long chunkLen5 = (decoder.readArrayStart()); Object oldArray4 = TestRecord.get(24); @@ -527,19 +632,28 @@ private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.Te if (oldArray4 instanceof GenericArray) { recordsArrayArrayElementReuseVar0 = ((GenericArray) oldArray4).peek(); } +<<<<<<< HEAD recordsArray0 .add(deserializeSubRecord0(recordsArrayArrayElementReuseVar0, (decoder))); +======= + recordsArray0 .add(deserializeSubRecord0(recordsArrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen5 = (decoder.arrayNext()); } TestRecord.put(24, recordsArray0); } +<<<<<<< HEAD private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map recordsMap0 = null; long chunkLen6 = (decoder.readMapStart()); if (chunkLen6 > 0) { +<<<<<<< HEAD Map recordsMapReuse0 = null; Object oldMap0 = TestRecord.get(25); if (oldMap0 instanceof Map) { @@ -550,16 +664,44 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te recordsMap0 = recordsMapReuse0; } else { recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter6 = 0; (counter6 >>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen6 = (decoder.mapNext()); } while (chunkLen6 > 0); } else { +<<<<<<< HEAD recordsMap0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(25, recordsMap0); int unionIndex14 = (decoder.readIndex()); @@ -593,7 +735,11 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayUnionOption0 .add(null); } else { if (unionIndex15 == 1) { +<<<<<<< HEAD recordsArrayUnionOption0 .add(deserializeSubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder))); +======= + recordsArrayUnionOption0 .add(deserializeSubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayUnionOptionElem': "+ unionIndex15)); } @@ -608,7 +754,11 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex16 = (decoder.readIndex()); @@ -620,6 +770,7 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te Map recordsMapUnionOption0 = null; long chunkLen8 = (decoder.readMapStart()); if (chunkLen8 > 0) { +<<<<<<< HEAD Map recordsMapUnionOptionReuse0 = null; Object oldMap1 = TestRecord.get(27); if (oldMap1 instanceof Map) { @@ -630,6 +781,22 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te recordsMapUnionOption0 = recordsMapUnionOptionReuse0; } else { recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter8 = 0; (counter8 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapUnionOptionValue': "+ unionIndex17)); } @@ -649,7 +820,15 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te chunkLen8 = (decoder.mapNext()); } while (chunkLen8 > 0); } else { +<<<<<<< HEAD recordsMapUnionOption0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(27, recordsMapUnionOption0); } else { @@ -678,6 +857,7 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te Map recordsArrayMapElem0 = null; long chunkLen10 = (decoder.readMapStart()); if (chunkLen10 > 0) { +<<<<<<< HEAD Map recordsArrayMapElemReuse0 = null; if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); @@ -687,6 +867,21 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayMapElem0 = recordsArrayMapElemReuse0; } else { recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter10 = 0; (counter10 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapElemValue': "+ unionIndex18)); } @@ -706,7 +905,15 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te chunkLen10 = (decoder.mapNext()); } while (chunkLen10 > 0); } else { +<<<<<<< HEAD recordsArrayMapElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMap0 .add(recordsArrayMapElem0); } @@ -715,12 +922,17 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(28, recordsArrayMap0); } +<<<<<<< HEAD private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map> recordsMapArray0 = null; long chunkLen11 = (decoder.readMapStart()); if (chunkLen11 > 0) { +<<<<<<< HEAD Map> recordsMapArrayReuse0 = null; Object oldMap2 = TestRecord.get(29); if (oldMap2 instanceof Map) { @@ -731,6 +943,22 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te recordsMapArray0 = recordsMapArrayReuse0; } else { recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter11 = 0; (counter11 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayValueElem': "+ unionIndex19)); } @@ -772,7 +1004,15 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te chunkLen11 = (decoder.mapNext()); } while (chunkLen11 > 0); } else { +<<<<<<< HEAD recordsMapArray0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(29, recordsMapArray0); int unionIndex20 = (decoder.readIndex()); @@ -803,6 +1043,7 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te Map recordsArrayMapUnionOptionElem0 = null; long chunkLen14 = (decoder.readMapStart()); if (chunkLen14 > 0) { +<<<<<<< HEAD Map recordsArrayMapUnionOptionElemReuse0 = null; if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); @@ -812,6 +1053,21 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; } else { recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter14 = 0; (counter14 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnionOptionElemValue': "+ unionIndex21)); } @@ -831,7 +1091,15 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te chunkLen14 = (decoder.mapNext()); } while (chunkLen14 > 0); } else { +<<<<<<< HEAD recordsArrayMapUnionOptionElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); } @@ -844,7 +1112,11 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex22 = (decoder.readIndex()); @@ -856,6 +1128,7 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te Map> recordsMapArrayUnionOption0 = null; long chunkLen15 = (decoder.readMapStart()); if (chunkLen15 > 0) { +<<<<<<< HEAD Map> recordsMapArrayUnionOptionReuse0 = null; Object oldMap3 = TestRecord.get(31); if (oldMap3 instanceof Map) { @@ -866,6 +1139,22 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; } else { recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter15 = 0; (counter15 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnionOptionValueElem': "+ unionIndex23)); } @@ -907,7 +1200,15 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te chunkLen15 = (decoder.mapNext()); } while (chunkLen15 > 0); } else { +<<<<<<< HEAD recordsMapArrayUnionOption0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(31, recordsMapArrayUnionOption0); } else { @@ -920,7 +1221,11 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(32, null); } else { if (unionIndex24 == 1) { +<<<<<<< HEAD TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder))); +======= + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { if (unionIndex24 == 2) { Utf8 charSequence4; @@ -942,7 +1247,11 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveBooleanList booleanArray0 = null; @@ -979,7 +1288,11 @@ private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(34, doubleArray0); } +<<<<<<< HEAD private void populate_TestRecord17(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord17(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveFloatList floatArray0 = null; @@ -1003,7 +1316,11 @@ private void populate_TestRecord17(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(36, intArray0); } +<<<<<<< HEAD private void populate_TestRecord18(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord18(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveLongList longArray0 = null; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_UNION_GenericDeserializer_777827233_777827233.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_UNION_GenericDeserializer_777827233_777827233.java index b5e64128e..8a5268f39 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_UNION_GenericDeserializer_777827233_777827233.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_UNION_GenericDeserializer_777827233_777827233.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.generic.IndexedRecord; @@ -26,7 +30,11 @@ public Array_of_UNION_GenericDeserializer_777827233_777827233(Schema readerSchem this.field0 = arrayElemOptionSchema0 .getField("field").schema(); } +<<<<<<< HEAD public List deserialize(List reuse, Decoder decoder) +======= + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List array0 = null; @@ -53,7 +61,11 @@ public List deserialize(List reuse, Decoder decode array0 .add(null); } else { if (unionIndex0 == 1) { +<<<<<<< HEAD array0 .add(deserializerecord0(arrayArrayElementReuseVar0, (decoder))); +======= + array0 .add(deserializerecord0(arrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'arrayElem': "+ unionIndex0)); } @@ -64,7 +76,11 @@ public List deserialize(List reuse, Decoder decode return array0; } +<<<<<<< HEAD public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_UNION_SpecificDeserializer_1277939469_1277939469.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_UNION_SpecificDeserializer_1277939469_1277939469.java index 24eaa7b1a..1fc369f27 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_UNION_SpecificDeserializer_1277939469_1277939469.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_UNION_SpecificDeserializer_1277939469_1277939469.java @@ -14,6 +14,10 @@ import com.linkedin.avro.api.PrimitiveLongList; import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.generated.avro.TestEnum; import com.linkedin.avro.fastserde.generated.avro.TestFixed; import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; @@ -37,7 +41,11 @@ public Array_of_UNION_SpecificDeserializer_1277939469_1277939469(Schema readerSc this.readerSchema = readerSchema; } +<<<<<<< HEAD public List deserialize(List reuse, Decoder decoder) +======= + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List array0 = null; @@ -64,7 +72,11 @@ public List deserialize(L array0 .add(null); } else { if (unionIndex0 == 1) { +<<<<<<< HEAD array0 .add(deserializeTestRecord0(arrayArrayElementReuseVar0, (decoder))); +======= + array0 .add(deserializeTestRecord0(arrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'arrayElem': "+ unionIndex0)); } @@ -75,7 +87,11 @@ public List deserialize(L return array0; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; @@ -85,6 +101,7 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); } TestRecord.put(0, (decoder.readInt())); +<<<<<<< HEAD populate_TestRecord0((TestRecord), (decoder)); populate_TestRecord1((TestRecord), (decoder)); populate_TestRecord2((TestRecord), (decoder)); @@ -108,6 +125,31 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco } private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex1 = (decoder.readIndex()); @@ -124,7 +166,11 @@ private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(2, (decoder.readLong())); } +<<<<<<< HEAD private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex2 = (decoder.readIndex()); @@ -141,7 +187,11 @@ private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(4, (decoder.readDouble())); } +<<<<<<< HEAD private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); @@ -158,7 +208,11 @@ private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(6, (decoder.readFloat())); } +<<<<<<< HEAD private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex4 = (decoder.readIndex()); @@ -175,7 +229,11 @@ private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(8, (decoder.readBoolean())); } +<<<<<<< HEAD private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex5 = (decoder.readIndex()); @@ -199,7 +257,11 @@ private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(10, byteBuffer0); } +<<<<<<< HEAD private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex6 = (decoder.readIndex()); @@ -230,7 +292,11 @@ private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(12, charSequence0); } +<<<<<<< HEAD private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex7 = (decoder.readIndex()); @@ -264,7 +330,11 @@ private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(14, testFixed1); } +<<<<<<< HEAD private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex8 = (decoder.readIndex()); @@ -324,7 +394,11 @@ private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(16, testFixedArray0); } +<<<<<<< HEAD private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testFixedUnionArray0 = null; @@ -374,7 +448,11 @@ private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(18, Enums.getConstant(TestEnum.class, (decoder.readEnum()))); } +<<<<<<< HEAD private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex10 = (decoder.readIndex()); @@ -410,7 +488,11 @@ private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(20, testEnumArray0); } +<<<<<<< HEAD private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testEnumUnionArray0 = null; @@ -453,14 +535,22 @@ private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(22, null); } else { if (unionIndex12 == 1) { +<<<<<<< HEAD TestRecord.put(22, deserializeSubRecord0(TestRecord.get(22), (decoder))); +======= + TestRecord.put(22, deserializeSubRecord0(TestRecord.get(22), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'subRecordUnion': "+ unionIndex12)); } } } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord; @@ -487,11 +577,19 @@ public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex13)); } } +<<<<<<< HEAD populate_SubRecord0((SubRecord), (decoder)); return SubRecord; } private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord, Decoder decoder) +======= + populate_SubRecord0((SubRecord), (customization), (decoder)); + return SubRecord; + } + + private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex14 = (decoder.readIndex()); @@ -514,10 +612,17 @@ private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubR } } +<<<<<<< HEAD private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) throws IOException { TestRecord.put(23, deserializeSubRecord0(TestRecord.get(23), (decoder))); +======= + private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + TestRecord.put(23, deserializeSubRecord0(TestRecord.get(23), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) List recordsArray0 = null; long chunkLen5 = (decoder.readArrayStart()); Object oldArray4 = TestRecord.get(24); @@ -537,19 +642,28 @@ private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.Te if (oldArray4 instanceof GenericArray) { recordsArrayArrayElementReuseVar0 = ((GenericArray) oldArray4).peek(); } +<<<<<<< HEAD recordsArray0 .add(deserializeSubRecord0(recordsArrayArrayElementReuseVar0, (decoder))); +======= + recordsArray0 .add(deserializeSubRecord0(recordsArrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen5 = (decoder.arrayNext()); } TestRecord.put(24, recordsArray0); } +<<<<<<< HEAD private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map recordsMap0 = null; long chunkLen6 = (decoder.readMapStart()); if (chunkLen6 > 0) { +<<<<<<< HEAD Map recordsMapReuse0 = null; Object oldMap0 = TestRecord.get(25); if (oldMap0 instanceof Map) { @@ -560,16 +674,44 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te recordsMap0 = recordsMapReuse0; } else { recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter6 = 0; (counter6 >>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen6 = (decoder.mapNext()); } while (chunkLen6 > 0); } else { +<<<<<<< HEAD recordsMap0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(25, recordsMap0); int unionIndex15 = (decoder.readIndex()); @@ -603,7 +745,11 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayUnionOption0 .add(null); } else { if (unionIndex16 == 1) { +<<<<<<< HEAD recordsArrayUnionOption0 .add(deserializeSubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder))); +======= + recordsArrayUnionOption0 .add(deserializeSubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayUnionOptionElem': "+ unionIndex16)); } @@ -618,7 +764,11 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex17 = (decoder.readIndex()); @@ -630,6 +780,7 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te Map recordsMapUnionOption0 = null; long chunkLen8 = (decoder.readMapStart()); if (chunkLen8 > 0) { +<<<<<<< HEAD Map recordsMapUnionOptionReuse0 = null; Object oldMap1 = TestRecord.get(27); if (oldMap1 instanceof Map) { @@ -640,6 +791,22 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te recordsMapUnionOption0 = recordsMapUnionOptionReuse0; } else { recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter8 = 0; (counter8 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapUnionOptionValue': "+ unionIndex18)); } @@ -659,7 +830,15 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te chunkLen8 = (decoder.mapNext()); } while (chunkLen8 > 0); } else { +<<<<<<< HEAD recordsMapUnionOption0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(27, recordsMapUnionOption0); } else { @@ -688,6 +867,7 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te Map recordsArrayMapElem0 = null; long chunkLen10 = (decoder.readMapStart()); if (chunkLen10 > 0) { +<<<<<<< HEAD Map recordsArrayMapElemReuse0 = null; if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); @@ -697,6 +877,21 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayMapElem0 = recordsArrayMapElemReuse0; } else { recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter10 = 0; (counter10 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapElemValue': "+ unionIndex19)); } @@ -716,7 +915,15 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te chunkLen10 = (decoder.mapNext()); } while (chunkLen10 > 0); } else { +<<<<<<< HEAD recordsArrayMapElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMap0 .add(recordsArrayMapElem0); } @@ -725,12 +932,17 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(28, recordsArrayMap0); } +<<<<<<< HEAD private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map> recordsMapArray0 = null; long chunkLen11 = (decoder.readMapStart()); if (chunkLen11 > 0) { +<<<<<<< HEAD Map> recordsMapArrayReuse0 = null; Object oldMap2 = TestRecord.get(29); if (oldMap2 instanceof Map) { @@ -741,6 +953,22 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te recordsMapArray0 = recordsMapArrayReuse0; } else { recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter11 = 0; (counter11 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayValueElem': "+ unionIndex20)); } @@ -782,7 +1014,15 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te chunkLen11 = (decoder.mapNext()); } while (chunkLen11 > 0); } else { +<<<<<<< HEAD recordsMapArray0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(29, recordsMapArray0); int unionIndex21 = (decoder.readIndex()); @@ -813,6 +1053,7 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te Map recordsArrayMapUnionOptionElem0 = null; long chunkLen14 = (decoder.readMapStart()); if (chunkLen14 > 0) { +<<<<<<< HEAD Map recordsArrayMapUnionOptionElemReuse0 = null; if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); @@ -822,6 +1063,21 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; } else { recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter14 = 0; (counter14 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnionOptionElemValue': "+ unionIndex22)); } @@ -841,7 +1101,15 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te chunkLen14 = (decoder.mapNext()); } while (chunkLen14 > 0); } else { +<<<<<<< HEAD recordsArrayMapUnionOptionElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); } @@ -854,7 +1122,11 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex23 = (decoder.readIndex()); @@ -866,6 +1138,7 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te Map> recordsMapArrayUnionOption0 = null; long chunkLen15 = (decoder.readMapStart()); if (chunkLen15 > 0) { +<<<<<<< HEAD Map> recordsMapArrayUnionOptionReuse0 = null; Object oldMap3 = TestRecord.get(31); if (oldMap3 instanceof Map) { @@ -876,6 +1149,22 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; } else { recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter15 = 0; (counter15 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnionOptionValueElem': "+ unionIndex24)); } @@ -917,7 +1210,15 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te chunkLen15 = (decoder.mapNext()); } while (chunkLen15 > 0); } else { +<<<<<<< HEAD recordsMapArrayUnionOption0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(31, recordsMapArrayUnionOption0); } else { @@ -930,7 +1231,11 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(32, null); } else { if (unionIndex25 == 1) { +<<<<<<< HEAD TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder))); +======= + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { if (unionIndex25 == 2) { Utf8 charSequence4; @@ -952,7 +1257,11 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveBooleanList booleanArray0 = null; @@ -989,7 +1298,11 @@ private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(34, doubleArray0); } +<<<<<<< HEAD private void populate_TestRecord17(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord17(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveFloatList floatArray0 = null; @@ -1013,7 +1326,11 @@ private void populate_TestRecord17(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(36, intArray0); } +<<<<<<< HEAD private void populate_TestRecord18(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord18(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveLongList longArray0 = null; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_record_GenericDeserializer_1606337179_2018567528.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_record_GenericDeserializer_1606337179_2018567528.java index a316aef3b..0e5968582 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_record_GenericDeserializer_1606337179_2018567528.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_record_GenericDeserializer_1606337179_2018567528.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.AvroTypeException; import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; @@ -22,7 +26,11 @@ public Array_of_record_GenericDeserializer_1606337179_2018567528(Schema readerSc this.unionOptionArrayElemSchema0 = readerSchema.getElementType(); } +<<<<<<< HEAD public List deserialize(List reuse, Decoder decoder) +======= + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -48,7 +56,11 @@ public List deserialize(List reuse, Decoder decode if ((reuse) instanceof GenericArray) { unionOptionArrayElementReuseVar0 = ((GenericArray)(reuse)).peek(); } +<<<<<<< HEAD unionOption0 .add(deserializerecord0(unionOptionArrayElementReuseVar0, (decoder))); +======= + unionOption0 .add(deserializerecord0(unionOptionArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen0 = (decoder.arrayNext()); } @@ -59,7 +71,11 @@ public List deserialize(List reuse, Decoder decode } } +<<<<<<< HEAD public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_record_GenericDeserializer_477614132_477614132.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_record_GenericDeserializer_477614132_477614132.java index 362a2f8fb..aad860c7d 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_record_GenericDeserializer_477614132_477614132.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Array_of_record_GenericDeserializer_477614132_477614132.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.generic.IndexedRecord; @@ -24,7 +28,11 @@ public Array_of_record_GenericDeserializer_477614132_477614132(Schema readerSche this.field0 = arrayArrayElemSchema0 .getField("field").schema(); } +<<<<<<< HEAD public List deserialize(List reuse, Decoder decoder) +======= + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List array0 = null; @@ -45,14 +53,22 @@ public List deserialize(List reuse, Decoder decode if ((reuse) instanceof GenericArray) { arrayArrayElementReuseVar0 = ((GenericArray)(reuse)).peek(); } +<<<<<<< HEAD array0 .add(deserializerecord0(arrayArrayElementReuseVar0, (decoder))); +======= + array0 .add(deserializerecord0(arrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen0 = (decoder.arrayNext()); } return array0; } +<<<<<<< HEAD public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema_GenericDeserializer_836892732_836892732.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema_GenericDeserializer_836892732_836892732.java index e19c97cd8..9b5add82d 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema_GenericDeserializer_836892732_836892732.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema_GenericDeserializer_836892732_836892732.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -2018,6 +2022,7 @@ public FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema_Ge this.f9990 = readerSchema.getField("F999").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -2025,6 +2030,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; @@ -2051,6 +2065,7 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldBeAbl throw new RuntimeException(("Illegal union index for 'F0': "+ unionIndex0)); } } +<<<<<<< HEAD populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (decoder)); populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (decoder)); populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (decoder)); @@ -2555,6 +2570,512 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldBeAbl } private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex1 = (decoder.readIndex()); @@ -2595,7 +3116,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); @@ -2636,7 +3161,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex5 = (decoder.readIndex()); @@ -2677,7 +3206,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex7 = (decoder.readIndex()); @@ -2718,7 +3251,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex9 = (decoder.readIndex()); @@ -2759,7 +3296,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex11 = (decoder.readIndex()); @@ -2800,7 +3341,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex13 = (decoder.readIndex()); @@ -2841,7 +3386,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex15 = (decoder.readIndex()); @@ -2882,7 +3431,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex17 = (decoder.readIndex()); @@ -2923,7 +3476,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex19 = (decoder.readIndex()); @@ -2964,7 +3521,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex21 = (decoder.readIndex()); @@ -3005,7 +3566,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex23 = (decoder.readIndex()); @@ -3046,7 +3611,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex25 = (decoder.readIndex()); @@ -3087,7 +3656,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex27 = (decoder.readIndex()); @@ -3128,7 +3701,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex29 = (decoder.readIndex()); @@ -3169,7 +3746,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex31 = (decoder.readIndex()); @@ -3210,7 +3791,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex33 = (decoder.readIndex()); @@ -3251,7 +3836,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex35 = (decoder.readIndex()); @@ -3292,7 +3881,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex37 = (decoder.readIndex()); @@ -3333,7 +3926,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex39 = (decoder.readIndex()); @@ -3374,7 +3971,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex41 = (decoder.readIndex()); @@ -3415,7 +4016,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex43 = (decoder.readIndex()); @@ -3456,7 +4061,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex45 = (decoder.readIndex()); @@ -3497,7 +4106,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex47 = (decoder.readIndex()); @@ -3538,7 +4151,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex49 = (decoder.readIndex()); @@ -3579,7 +4196,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex51 = (decoder.readIndex()); @@ -3620,7 +4241,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex53 = (decoder.readIndex()); @@ -3661,7 +4286,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex55 = (decoder.readIndex()); @@ -3702,7 +4331,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex57 = (decoder.readIndex()); @@ -3743,7 +4376,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex59 = (decoder.readIndex()); @@ -3784,7 +4421,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex61 = (decoder.readIndex()); @@ -3825,7 +4466,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex63 = (decoder.readIndex()); @@ -3866,7 +4511,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex65 = (decoder.readIndex()); @@ -3907,7 +4556,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex67 = (decoder.readIndex()); @@ -3948,7 +4601,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex69 = (decoder.readIndex()); @@ -3989,7 +4646,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex71 = (decoder.readIndex()); @@ -4030,7 +4691,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex73 = (decoder.readIndex()); @@ -4071,7 +4736,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex75 = (decoder.readIndex()); @@ -4112,7 +4781,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex77 = (decoder.readIndex()); @@ -4153,7 +4826,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex79 = (decoder.readIndex()); @@ -4194,7 +4871,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex81 = (decoder.readIndex()); @@ -4235,7 +4916,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex83 = (decoder.readIndex()); @@ -4276,7 +4961,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex85 = (decoder.readIndex()); @@ -4317,7 +5006,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex87 = (decoder.readIndex()); @@ -4358,7 +5051,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex89 = (decoder.readIndex()); @@ -4399,7 +5096,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex91 = (decoder.readIndex()); @@ -4440,7 +5141,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex93 = (decoder.readIndex()); @@ -4481,7 +5186,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex95 = (decoder.readIndex()); @@ -4522,7 +5231,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex97 = (decoder.readIndex()); @@ -4563,7 +5276,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex99 = (decoder.readIndex()); @@ -4604,7 +5321,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex101 = (decoder.readIndex()); @@ -4645,7 +5366,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex103 = (decoder.readIndex()); @@ -4686,7 +5411,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex105 = (decoder.readIndex()); @@ -4727,7 +5456,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex107 = (decoder.readIndex()); @@ -4768,7 +5501,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex109 = (decoder.readIndex()); @@ -4809,7 +5546,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex111 = (decoder.readIndex()); @@ -4850,7 +5591,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex113 = (decoder.readIndex()); @@ -4891,7 +5636,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex115 = (decoder.readIndex()); @@ -4932,7 +5681,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex117 = (decoder.readIndex()); @@ -4973,7 +5726,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex119 = (decoder.readIndex()); @@ -5014,7 +5771,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex121 = (decoder.readIndex()); @@ -5055,7 +5816,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex123 = (decoder.readIndex()); @@ -5096,7 +5861,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex125 = (decoder.readIndex()); @@ -5137,7 +5906,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex127 = (decoder.readIndex()); @@ -5178,7 +5951,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex129 = (decoder.readIndex()); @@ -5219,7 +5996,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex131 = (decoder.readIndex()); @@ -5260,7 +6041,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex133 = (decoder.readIndex()); @@ -5301,7 +6086,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex135 = (decoder.readIndex()); @@ -5342,7 +6131,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex137 = (decoder.readIndex()); @@ -5383,7 +6176,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex139 = (decoder.readIndex()); @@ -5424,7 +6221,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex141 = (decoder.readIndex()); @@ -5465,7 +6266,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex143 = (decoder.readIndex()); @@ -5506,7 +6311,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex145 = (decoder.readIndex()); @@ -5547,7 +6356,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex147 = (decoder.readIndex()); @@ -5588,7 +6401,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex149 = (decoder.readIndex()); @@ -5629,7 +6446,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex151 = (decoder.readIndex()); @@ -5670,7 +6491,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex153 = (decoder.readIndex()); @@ -5711,7 +6536,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex155 = (decoder.readIndex()); @@ -5752,7 +6581,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex157 = (decoder.readIndex()); @@ -5793,7 +6626,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex159 = (decoder.readIndex()); @@ -5834,7 +6671,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex161 = (decoder.readIndex()); @@ -5875,7 +6716,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex163 = (decoder.readIndex()); @@ -5916,7 +6761,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex165 = (decoder.readIndex()); @@ -5957,7 +6806,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex167 = (decoder.readIndex()); @@ -5998,7 +6851,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex169 = (decoder.readIndex()); @@ -6039,7 +6896,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex171 = (decoder.readIndex()); @@ -6080,7 +6941,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex173 = (decoder.readIndex()); @@ -6121,7 +6986,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex175 = (decoder.readIndex()); @@ -6162,7 +7031,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex177 = (decoder.readIndex()); @@ -6203,7 +7076,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex179 = (decoder.readIndex()); @@ -6244,7 +7121,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex181 = (decoder.readIndex()); @@ -6285,7 +7166,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex183 = (decoder.readIndex()); @@ -6326,7 +7211,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex185 = (decoder.readIndex()); @@ -6367,7 +7256,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex187 = (decoder.readIndex()); @@ -6408,7 +7301,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex189 = (decoder.readIndex()); @@ -6449,7 +7346,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex191 = (decoder.readIndex()); @@ -6490,7 +7391,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex193 = (decoder.readIndex()); @@ -6531,7 +7436,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex195 = (decoder.readIndex()); @@ -6572,7 +7481,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex197 = (decoder.readIndex()); @@ -6613,7 +7526,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex199 = (decoder.readIndex()); @@ -6654,7 +7571,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex201 = (decoder.readIndex()); @@ -6695,7 +7616,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex203 = (decoder.readIndex()); @@ -6736,7 +7661,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex205 = (decoder.readIndex()); @@ -6777,7 +7706,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex207 = (decoder.readIndex()); @@ -6818,7 +7751,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex209 = (decoder.readIndex()); @@ -6859,7 +7796,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex211 = (decoder.readIndex()); @@ -6900,7 +7841,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex213 = (decoder.readIndex()); @@ -6941,7 +7886,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex215 = (decoder.readIndex()); @@ -6982,7 +7931,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex217 = (decoder.readIndex()); @@ -7023,7 +7976,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex219 = (decoder.readIndex()); @@ -7064,7 +8021,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex221 = (decoder.readIndex()); @@ -7105,7 +8066,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex223 = (decoder.readIndex()); @@ -7146,7 +8111,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex225 = (decoder.readIndex()); @@ -7187,7 +8156,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex227 = (decoder.readIndex()); @@ -7228,7 +8201,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex229 = (decoder.readIndex()); @@ -7269,7 +8246,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex231 = (decoder.readIndex()); @@ -7310,7 +8291,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex233 = (decoder.readIndex()); @@ -7351,7 +8336,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex235 = (decoder.readIndex()); @@ -7392,7 +8381,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex237 = (decoder.readIndex()); @@ -7433,7 +8426,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex239 = (decoder.readIndex()); @@ -7474,7 +8471,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex241 = (decoder.readIndex()); @@ -7515,7 +8516,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex243 = (decoder.readIndex()); @@ -7556,7 +8561,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex245 = (decoder.readIndex()); @@ -7597,7 +8606,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex247 = (decoder.readIndex()); @@ -7638,7 +8651,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex249 = (decoder.readIndex()); @@ -7679,7 +8696,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex251 = (decoder.readIndex()); @@ -7720,7 +8741,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex253 = (decoder.readIndex()); @@ -7761,7 +8786,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex255 = (decoder.readIndex()); @@ -7802,7 +8831,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex257 = (decoder.readIndex()); @@ -7843,7 +8876,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex259 = (decoder.readIndex()); @@ -7884,7 +8921,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex261 = (decoder.readIndex()); @@ -7925,7 +8966,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex263 = (decoder.readIndex()); @@ -7966,7 +9011,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex265 = (decoder.readIndex()); @@ -8007,7 +9056,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex267 = (decoder.readIndex()); @@ -8048,7 +9101,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex269 = (decoder.readIndex()); @@ -8089,7 +9146,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex271 = (decoder.readIndex()); @@ -8130,7 +9191,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex273 = (decoder.readIndex()); @@ -8171,7 +9236,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex275 = (decoder.readIndex()); @@ -8212,7 +9281,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex277 = (decoder.readIndex()); @@ -8253,7 +9326,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex279 = (decoder.readIndex()); @@ -8294,7 +9371,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex281 = (decoder.readIndex()); @@ -8335,7 +9416,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex283 = (decoder.readIndex()); @@ -8376,7 +9461,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex285 = (decoder.readIndex()); @@ -8417,7 +9506,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex287 = (decoder.readIndex()); @@ -8458,7 +9551,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex289 = (decoder.readIndex()); @@ -8499,7 +9596,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex291 = (decoder.readIndex()); @@ -8540,7 +9641,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex293 = (decoder.readIndex()); @@ -8581,7 +9686,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex295 = (decoder.readIndex()); @@ -8622,7 +9731,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex297 = (decoder.readIndex()); @@ -8663,7 +9776,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex299 = (decoder.readIndex()); @@ -8704,7 +9821,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex301 = (decoder.readIndex()); @@ -8745,7 +9866,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex303 = (decoder.readIndex()); @@ -8786,7 +9911,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex305 = (decoder.readIndex()); @@ -8827,7 +9956,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex307 = (decoder.readIndex()); @@ -8868,7 +10001,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex309 = (decoder.readIndex()); @@ -8909,7 +10046,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex311 = (decoder.readIndex()); @@ -8950,7 +10091,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex313 = (decoder.readIndex()); @@ -8991,7 +10136,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex315 = (decoder.readIndex()); @@ -9032,7 +10181,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex317 = (decoder.readIndex()); @@ -9073,7 +10226,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex319 = (decoder.readIndex()); @@ -9114,7 +10271,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex321 = (decoder.readIndex()); @@ -9155,7 +10316,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex323 = (decoder.readIndex()); @@ -9196,7 +10361,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex325 = (decoder.readIndex()); @@ -9237,7 +10406,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex327 = (decoder.readIndex()); @@ -9278,7 +10451,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex329 = (decoder.readIndex()); @@ -9319,7 +10496,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex331 = (decoder.readIndex()); @@ -9360,7 +10541,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex333 = (decoder.readIndex()); @@ -9401,7 +10586,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex335 = (decoder.readIndex()); @@ -9442,7 +10631,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex337 = (decoder.readIndex()); @@ -9483,7 +10676,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex339 = (decoder.readIndex()); @@ -9524,7 +10721,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex341 = (decoder.readIndex()); @@ -9565,7 +10766,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex343 = (decoder.readIndex()); @@ -9606,7 +10811,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex345 = (decoder.readIndex()); @@ -9647,7 +10856,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex347 = (decoder.readIndex()); @@ -9688,7 +10901,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex349 = (decoder.readIndex()); @@ -9729,7 +10946,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex351 = (decoder.readIndex()); @@ -9770,7 +10991,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex353 = (decoder.readIndex()); @@ -9811,7 +11036,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex355 = (decoder.readIndex()); @@ -9852,7 +11081,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex357 = (decoder.readIndex()); @@ -9893,7 +11126,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex359 = (decoder.readIndex()); @@ -9934,7 +11171,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex361 = (decoder.readIndex()); @@ -9975,7 +11216,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex363 = (decoder.readIndex()); @@ -10016,7 +11261,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex365 = (decoder.readIndex()); @@ -10057,7 +11306,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex367 = (decoder.readIndex()); @@ -10098,7 +11351,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex369 = (decoder.readIndex()); @@ -10139,7 +11396,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex371 = (decoder.readIndex()); @@ -10180,7 +11441,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex373 = (decoder.readIndex()); @@ -10221,7 +11486,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex375 = (decoder.readIndex()); @@ -10262,7 +11531,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex377 = (decoder.readIndex()); @@ -10303,7 +11576,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex379 = (decoder.readIndex()); @@ -10344,7 +11621,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex381 = (decoder.readIndex()); @@ -10385,7 +11666,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex383 = (decoder.readIndex()); @@ -10426,7 +11711,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex385 = (decoder.readIndex()); @@ -10467,7 +11756,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex387 = (decoder.readIndex()); @@ -10508,7 +11801,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex389 = (decoder.readIndex()); @@ -10549,7 +11846,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex391 = (decoder.readIndex()); @@ -10590,7 +11891,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex393 = (decoder.readIndex()); @@ -10631,7 +11936,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex395 = (decoder.readIndex()); @@ -10672,7 +11981,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex397 = (decoder.readIndex()); @@ -10713,7 +12026,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex399 = (decoder.readIndex()); @@ -10754,7 +12071,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex401 = (decoder.readIndex()); @@ -10795,7 +12116,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex403 = (decoder.readIndex()); @@ -10836,7 +12161,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex405 = (decoder.readIndex()); @@ -10877,7 +12206,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex407 = (decoder.readIndex()); @@ -10918,7 +12251,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex409 = (decoder.readIndex()); @@ -10959,7 +12296,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex411 = (decoder.readIndex()); @@ -11000,7 +12341,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex413 = (decoder.readIndex()); @@ -11041,7 +12386,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex415 = (decoder.readIndex()); @@ -11082,7 +12431,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex417 = (decoder.readIndex()); @@ -11123,7 +12476,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex419 = (decoder.readIndex()); @@ -11164,7 +12521,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex421 = (decoder.readIndex()); @@ -11205,7 +12566,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex423 = (decoder.readIndex()); @@ -11246,7 +12611,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex425 = (decoder.readIndex()); @@ -11287,7 +12656,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex427 = (decoder.readIndex()); @@ -11328,7 +12701,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex429 = (decoder.readIndex()); @@ -11369,7 +12746,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex431 = (decoder.readIndex()); @@ -11410,7 +12791,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex433 = (decoder.readIndex()); @@ -11451,7 +12836,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex435 = (decoder.readIndex()); @@ -11492,7 +12881,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex437 = (decoder.readIndex()); @@ -11533,7 +12926,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex439 = (decoder.readIndex()); @@ -11574,7 +12971,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex441 = (decoder.readIndex()); @@ -11615,7 +13016,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex443 = (decoder.readIndex()); @@ -11656,7 +13061,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex445 = (decoder.readIndex()); @@ -11697,7 +13106,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex447 = (decoder.readIndex()); @@ -11738,7 +13151,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex449 = (decoder.readIndex()); @@ -11779,7 +13196,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex451 = (decoder.readIndex()); @@ -11820,7 +13241,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex453 = (decoder.readIndex()); @@ -11861,7 +13286,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex455 = (decoder.readIndex()); @@ -11902,7 +13331,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex457 = (decoder.readIndex()); @@ -11943,7 +13376,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex459 = (decoder.readIndex()); @@ -11984,7 +13421,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex461 = (decoder.readIndex()); @@ -12025,7 +13466,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex463 = (decoder.readIndex()); @@ -12066,7 +13511,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex465 = (decoder.readIndex()); @@ -12107,7 +13556,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex467 = (decoder.readIndex()); @@ -12148,7 +13601,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex469 = (decoder.readIndex()); @@ -12189,7 +13646,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex471 = (decoder.readIndex()); @@ -12230,7 +13691,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex473 = (decoder.readIndex()); @@ -12271,7 +13736,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex475 = (decoder.readIndex()); @@ -12312,7 +13781,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex477 = (decoder.readIndex()); @@ -12353,7 +13826,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex479 = (decoder.readIndex()); @@ -12394,7 +13871,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex481 = (decoder.readIndex()); @@ -12435,7 +13916,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex483 = (decoder.readIndex()); @@ -12476,7 +13961,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex485 = (decoder.readIndex()); @@ -12517,7 +14006,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex487 = (decoder.readIndex()); @@ -12558,7 +14051,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex489 = (decoder.readIndex()); @@ -12599,7 +14096,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex491 = (decoder.readIndex()); @@ -12640,7 +14141,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex493 = (decoder.readIndex()); @@ -12681,7 +14186,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex495 = (decoder.readIndex()); @@ -12722,7 +14231,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex497 = (decoder.readIndex()); @@ -12763,7 +14276,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex499 = (decoder.readIndex()); @@ -12804,7 +14321,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex501 = (decoder.readIndex()); @@ -12845,7 +14366,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex503 = (decoder.readIndex()); @@ -12886,7 +14411,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex505 = (decoder.readIndex()); @@ -12927,7 +14456,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex507 = (decoder.readIndex()); @@ -12968,7 +14501,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex509 = (decoder.readIndex()); @@ -13009,7 +14546,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex511 = (decoder.readIndex()); @@ -13050,7 +14591,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex513 = (decoder.readIndex()); @@ -13091,7 +14636,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex515 = (decoder.readIndex()); @@ -13132,7 +14681,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex517 = (decoder.readIndex()); @@ -13173,7 +14726,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex519 = (decoder.readIndex()); @@ -13214,7 +14771,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex521 = (decoder.readIndex()); @@ -13255,7 +14816,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex523 = (decoder.readIndex()); @@ -13296,7 +14861,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex525 = (decoder.readIndex()); @@ -13337,7 +14906,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex527 = (decoder.readIndex()); @@ -13378,7 +14951,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex529 = (decoder.readIndex()); @@ -13419,7 +14996,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex531 = (decoder.readIndex()); @@ -13460,7 +15041,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex533 = (decoder.readIndex()); @@ -13501,7 +15086,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex535 = (decoder.readIndex()); @@ -13542,7 +15131,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex537 = (decoder.readIndex()); @@ -13583,7 +15176,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex539 = (decoder.readIndex()); @@ -13624,7 +15221,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex541 = (decoder.readIndex()); @@ -13665,7 +15266,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex543 = (decoder.readIndex()); @@ -13706,7 +15311,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex545 = (decoder.readIndex()); @@ -13747,7 +15356,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex547 = (decoder.readIndex()); @@ -13788,7 +15401,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex549 = (decoder.readIndex()); @@ -13829,7 +15446,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex551 = (decoder.readIndex()); @@ -13870,7 +15491,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex553 = (decoder.readIndex()); @@ -13911,7 +15536,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex555 = (decoder.readIndex()); @@ -13952,7 +15581,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex557 = (decoder.readIndex()); @@ -13993,7 +15626,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex559 = (decoder.readIndex()); @@ -14034,7 +15671,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex561 = (decoder.readIndex()); @@ -14075,7 +15716,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex563 = (decoder.readIndex()); @@ -14116,7 +15761,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex565 = (decoder.readIndex()); @@ -14157,7 +15806,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex567 = (decoder.readIndex()); @@ -14198,7 +15851,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex569 = (decoder.readIndex()); @@ -14239,7 +15896,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex571 = (decoder.readIndex()); @@ -14280,7 +15941,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex573 = (decoder.readIndex()); @@ -14321,7 +15986,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex575 = (decoder.readIndex()); @@ -14362,7 +16031,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex577 = (decoder.readIndex()); @@ -14403,7 +16076,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex579 = (decoder.readIndex()); @@ -14444,7 +16121,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex581 = (decoder.readIndex()); @@ -14485,7 +16166,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex583 = (decoder.readIndex()); @@ -14526,7 +16211,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex585 = (decoder.readIndex()); @@ -14567,7 +16256,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex587 = (decoder.readIndex()); @@ -14608,7 +16301,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex589 = (decoder.readIndex()); @@ -14649,7 +16346,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex591 = (decoder.readIndex()); @@ -14690,7 +16391,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex593 = (decoder.readIndex()); @@ -14731,7 +16436,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex595 = (decoder.readIndex()); @@ -14772,7 +16481,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex597 = (decoder.readIndex()); @@ -14813,7 +16526,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex599 = (decoder.readIndex()); @@ -14854,7 +16571,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex601 = (decoder.readIndex()); @@ -14895,7 +16616,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex603 = (decoder.readIndex()); @@ -14936,7 +16661,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex605 = (decoder.readIndex()); @@ -14977,7 +16706,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex607 = (decoder.readIndex()); @@ -15018,7 +16751,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex609 = (decoder.readIndex()); @@ -15059,7 +16796,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex611 = (decoder.readIndex()); @@ -15100,7 +16841,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex613 = (decoder.readIndex()); @@ -15141,7 +16886,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex615 = (decoder.readIndex()); @@ -15182,7 +16931,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex617 = (decoder.readIndex()); @@ -15223,7 +16976,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex619 = (decoder.readIndex()); @@ -15264,7 +17021,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex621 = (decoder.readIndex()); @@ -15305,7 +17066,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex623 = (decoder.readIndex()); @@ -15346,7 +17111,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex625 = (decoder.readIndex()); @@ -15387,7 +17156,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex627 = (decoder.readIndex()); @@ -15428,7 +17201,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex629 = (decoder.readIndex()); @@ -15469,7 +17246,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex631 = (decoder.readIndex()); @@ -15510,7 +17291,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex633 = (decoder.readIndex()); @@ -15551,7 +17336,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex635 = (decoder.readIndex()); @@ -15592,7 +17381,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex637 = (decoder.readIndex()); @@ -15633,7 +17426,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex639 = (decoder.readIndex()); @@ -15674,7 +17471,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex641 = (decoder.readIndex()); @@ -15715,7 +17516,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex643 = (decoder.readIndex()); @@ -15756,7 +17561,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex645 = (decoder.readIndex()); @@ -15797,7 +17606,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex647 = (decoder.readIndex()); @@ -15838,7 +17651,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex649 = (decoder.readIndex()); @@ -15879,7 +17696,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex651 = (decoder.readIndex()); @@ -15920,7 +17741,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex653 = (decoder.readIndex()); @@ -15961,7 +17786,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex655 = (decoder.readIndex()); @@ -16002,7 +17831,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex657 = (decoder.readIndex()); @@ -16043,7 +17876,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex659 = (decoder.readIndex()); @@ -16084,7 +17921,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex661 = (decoder.readIndex()); @@ -16125,7 +17966,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex663 = (decoder.readIndex()); @@ -16166,7 +18011,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex665 = (decoder.readIndex()); @@ -16207,7 +18056,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex667 = (decoder.readIndex()); @@ -16248,7 +18101,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex669 = (decoder.readIndex()); @@ -16289,7 +18146,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex671 = (decoder.readIndex()); @@ -16330,7 +18191,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex673 = (decoder.readIndex()); @@ -16371,7 +18236,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex675 = (decoder.readIndex()); @@ -16412,7 +18281,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex677 = (decoder.readIndex()); @@ -16453,7 +18326,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex679 = (decoder.readIndex()); @@ -16494,7 +18371,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex681 = (decoder.readIndex()); @@ -16535,7 +18416,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex683 = (decoder.readIndex()); @@ -16576,7 +18461,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex685 = (decoder.readIndex()); @@ -16617,7 +18506,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex687 = (decoder.readIndex()); @@ -16658,7 +18551,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex689 = (decoder.readIndex()); @@ -16699,7 +18596,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex691 = (decoder.readIndex()); @@ -16740,7 +18641,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex693 = (decoder.readIndex()); @@ -16781,7 +18686,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex695 = (decoder.readIndex()); @@ -16822,7 +18731,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex697 = (decoder.readIndex()); @@ -16863,7 +18776,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex699 = (decoder.readIndex()); @@ -16904,7 +18821,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex701 = (decoder.readIndex()); @@ -16945,7 +18866,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex703 = (decoder.readIndex()); @@ -16986,7 +18911,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex705 = (decoder.readIndex()); @@ -17027,7 +18956,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex707 = (decoder.readIndex()); @@ -17068,7 +19001,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex709 = (decoder.readIndex()); @@ -17109,7 +19046,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex711 = (decoder.readIndex()); @@ -17150,7 +19091,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex713 = (decoder.readIndex()); @@ -17191,7 +19136,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex715 = (decoder.readIndex()); @@ -17232,7 +19181,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex717 = (decoder.readIndex()); @@ -17273,7 +19226,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex719 = (decoder.readIndex()); @@ -17314,7 +19271,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex721 = (decoder.readIndex()); @@ -17355,7 +19316,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex723 = (decoder.readIndex()); @@ -17396,7 +19361,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex725 = (decoder.readIndex()); @@ -17437,7 +19406,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex727 = (decoder.readIndex()); @@ -17478,7 +19451,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex729 = (decoder.readIndex()); @@ -17519,7 +19496,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex731 = (decoder.readIndex()); @@ -17560,7 +19541,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex733 = (decoder.readIndex()); @@ -17601,7 +19586,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex735 = (decoder.readIndex()); @@ -17642,7 +19631,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex737 = (decoder.readIndex()); @@ -17683,7 +19676,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex739 = (decoder.readIndex()); @@ -17724,7 +19721,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex741 = (decoder.readIndex()); @@ -17765,7 +19766,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex743 = (decoder.readIndex()); @@ -17806,7 +19811,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex745 = (decoder.readIndex()); @@ -17847,7 +19856,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex747 = (decoder.readIndex()); @@ -17888,7 +19901,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex749 = (decoder.readIndex()); @@ -17929,7 +19946,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex751 = (decoder.readIndex()); @@ -17970,7 +19991,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex753 = (decoder.readIndex()); @@ -18011,7 +20036,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex755 = (decoder.readIndex()); @@ -18052,7 +20081,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex757 = (decoder.readIndex()); @@ -18093,7 +20126,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex759 = (decoder.readIndex()); @@ -18134,7 +20171,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex761 = (decoder.readIndex()); @@ -18175,7 +20216,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex763 = (decoder.readIndex()); @@ -18216,7 +20261,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex765 = (decoder.readIndex()); @@ -18257,7 +20306,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex767 = (decoder.readIndex()); @@ -18298,7 +20351,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex769 = (decoder.readIndex()); @@ -18339,7 +20396,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex771 = (decoder.readIndex()); @@ -18380,7 +20441,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex773 = (decoder.readIndex()); @@ -18421,7 +20486,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex775 = (decoder.readIndex()); @@ -18462,7 +20531,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex777 = (decoder.readIndex()); @@ -18503,7 +20576,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex779 = (decoder.readIndex()); @@ -18544,7 +20621,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex781 = (decoder.readIndex()); @@ -18585,7 +20666,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex783 = (decoder.readIndex()); @@ -18626,7 +20711,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex785 = (decoder.readIndex()); @@ -18667,7 +20756,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex787 = (decoder.readIndex()); @@ -18708,7 +20801,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex789 = (decoder.readIndex()); @@ -18749,7 +20846,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex791 = (decoder.readIndex()); @@ -18790,7 +20891,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex793 = (decoder.readIndex()); @@ -18831,7 +20936,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex795 = (decoder.readIndex()); @@ -18872,7 +20981,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex797 = (decoder.readIndex()); @@ -18913,7 +21026,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex799 = (decoder.readIndex()); @@ -18954,7 +21071,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex801 = (decoder.readIndex()); @@ -18995,7 +21116,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex803 = (decoder.readIndex()); @@ -19036,7 +21161,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex805 = (decoder.readIndex()); @@ -19077,7 +21206,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex807 = (decoder.readIndex()); @@ -19118,7 +21251,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex809 = (decoder.readIndex()); @@ -19159,7 +21296,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex811 = (decoder.readIndex()); @@ -19200,7 +21341,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex813 = (decoder.readIndex()); @@ -19241,7 +21386,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex815 = (decoder.readIndex()); @@ -19282,7 +21431,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex817 = (decoder.readIndex()); @@ -19323,7 +21476,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex819 = (decoder.readIndex()); @@ -19364,7 +21521,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex821 = (decoder.readIndex()); @@ -19405,7 +21566,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex823 = (decoder.readIndex()); @@ -19446,7 +21611,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex825 = (decoder.readIndex()); @@ -19487,7 +21656,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex827 = (decoder.readIndex()); @@ -19528,7 +21701,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex829 = (decoder.readIndex()); @@ -19569,7 +21746,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex831 = (decoder.readIndex()); @@ -19610,7 +21791,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex833 = (decoder.readIndex()); @@ -19651,7 +21836,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex835 = (decoder.readIndex()); @@ -19692,7 +21881,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex837 = (decoder.readIndex()); @@ -19733,7 +21926,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex839 = (decoder.readIndex()); @@ -19774,7 +21971,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex841 = (decoder.readIndex()); @@ -19815,7 +22016,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex843 = (decoder.readIndex()); @@ -19856,7 +22061,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex845 = (decoder.readIndex()); @@ -19897,7 +22106,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex847 = (decoder.readIndex()); @@ -19938,7 +22151,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex849 = (decoder.readIndex()); @@ -19979,7 +22196,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex851 = (decoder.readIndex()); @@ -20020,7 +22241,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex853 = (decoder.readIndex()); @@ -20061,7 +22286,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex855 = (decoder.readIndex()); @@ -20102,7 +22331,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex857 = (decoder.readIndex()); @@ -20143,7 +22376,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex859 = (decoder.readIndex()); @@ -20184,7 +22421,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex861 = (decoder.readIndex()); @@ -20225,7 +22466,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex863 = (decoder.readIndex()); @@ -20266,7 +22511,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex865 = (decoder.readIndex()); @@ -20307,7 +22556,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex867 = (decoder.readIndex()); @@ -20348,7 +22601,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex869 = (decoder.readIndex()); @@ -20389,7 +22646,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex871 = (decoder.readIndex()); @@ -20430,7 +22691,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex873 = (decoder.readIndex()); @@ -20471,7 +22736,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex875 = (decoder.readIndex()); @@ -20512,7 +22781,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex877 = (decoder.readIndex()); @@ -20553,7 +22826,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex879 = (decoder.readIndex()); @@ -20594,7 +22871,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex881 = (decoder.readIndex()); @@ -20635,7 +22916,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex883 = (decoder.readIndex()); @@ -20676,7 +22961,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex885 = (decoder.readIndex()); @@ -20717,7 +23006,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex887 = (decoder.readIndex()); @@ -20758,7 +23051,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex889 = (decoder.readIndex()); @@ -20799,7 +23096,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex891 = (decoder.readIndex()); @@ -20840,7 +23141,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex893 = (decoder.readIndex()); @@ -20881,7 +23186,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex895 = (decoder.readIndex()); @@ -20922,7 +23231,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex897 = (decoder.readIndex()); @@ -20963,7 +23276,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex899 = (decoder.readIndex()); @@ -21004,7 +23321,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex901 = (decoder.readIndex()); @@ -21045,7 +23366,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex903 = (decoder.readIndex()); @@ -21086,7 +23411,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex905 = (decoder.readIndex()); @@ -21127,7 +23456,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex907 = (decoder.readIndex()); @@ -21168,7 +23501,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex909 = (decoder.readIndex()); @@ -21209,7 +23546,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex911 = (decoder.readIndex()); @@ -21250,7 +23591,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex913 = (decoder.readIndex()); @@ -21291,7 +23636,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex915 = (decoder.readIndex()); @@ -21332,7 +23681,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex917 = (decoder.readIndex()); @@ -21373,7 +23726,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex919 = (decoder.readIndex()); @@ -21414,7 +23771,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex921 = (decoder.readIndex()); @@ -21455,7 +23816,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex923 = (decoder.readIndex()); @@ -21496,7 +23861,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex925 = (decoder.readIndex()); @@ -21537,7 +23906,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex927 = (decoder.readIndex()); @@ -21578,7 +23951,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex929 = (decoder.readIndex()); @@ -21619,7 +23996,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex931 = (decoder.readIndex()); @@ -21660,7 +24041,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex933 = (decoder.readIndex()); @@ -21701,7 +24086,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex935 = (decoder.readIndex()); @@ -21742,7 +24131,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex937 = (decoder.readIndex()); @@ -21783,7 +24176,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex939 = (decoder.readIndex()); @@ -21824,7 +24221,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex941 = (decoder.readIndex()); @@ -21865,7 +24266,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex943 = (decoder.readIndex()); @@ -21906,7 +24311,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex945 = (decoder.readIndex()); @@ -21947,7 +24356,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex947 = (decoder.readIndex()); @@ -21988,7 +24401,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex949 = (decoder.readIndex()); @@ -22029,7 +24446,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex951 = (decoder.readIndex()); @@ -22070,7 +24491,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex953 = (decoder.readIndex()); @@ -22111,7 +24536,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex955 = (decoder.readIndex()); @@ -22152,7 +24581,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex957 = (decoder.readIndex()); @@ -22193,7 +24626,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex959 = (decoder.readIndex()); @@ -22234,7 +24671,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex961 = (decoder.readIndex()); @@ -22275,7 +24716,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex963 = (decoder.readIndex()); @@ -22316,7 +24761,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex965 = (decoder.readIndex()); @@ -22357,7 +24806,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex967 = (decoder.readIndex()); @@ -22398,7 +24851,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex969 = (decoder.readIndex()); @@ -22439,7 +24896,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex971 = (decoder.readIndex()); @@ -22480,7 +24941,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex973 = (decoder.readIndex()); @@ -22521,7 +24986,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex975 = (decoder.readIndex()); @@ -22562,7 +25031,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex977 = (decoder.readIndex()); @@ -22603,7 +25076,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex979 = (decoder.readIndex()); @@ -22644,7 +25121,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex981 = (decoder.readIndex()); @@ -22685,7 +25166,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex983 = (decoder.readIndex()); @@ -22726,7 +25211,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex985 = (decoder.readIndex()); @@ -22767,7 +25256,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex987 = (decoder.readIndex()); @@ -22808,7 +25301,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex989 = (decoder.readIndex()); @@ -22849,7 +25346,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex991 = (decoder.readIndex()); @@ -22890,7 +25391,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex993 = (decoder.readIndex()); @@ -22931,7 +25436,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex995 = (decoder.readIndex()); @@ -22972,7 +25481,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex997 = (decoder.readIndex()); @@ -23013,7 +25526,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVer } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex999 = (decoder.readIndex()); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java index e1343d7ac..4c109affe 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -22,6 +26,7 @@ public FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeseri this.testStringUnionAlias0 = readerSchema.getField("testStringUnionAlias").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -29,6 +34,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadAliasedField0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadAliasedField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadAliasedField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadAliasedField; @@ -55,11 +69,19 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadA throw new RuntimeException(("Illegal union index for 'testString': "+ unionIndex0)); } } +<<<<<<< HEAD populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0((FastGenericDeserializerGeneratorTest_shouldReadAliasedField), (decoder)); return FastGenericDeserializerGeneratorTest_shouldReadAliasedField; } private void populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadAliasedField, Decoder decoder) +======= + populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0((FastGenericDeserializerGeneratorTest_shouldReadAliasedField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadAliasedField; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadAliasedField, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex1 = (decoder.readIndex()); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadEnumDefault_GenericDeserializer_693116719_1739184158.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadEnumDefault_GenericDeserializer_693116719_1739184158.java index 320591b7e..610d402ad 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadEnumDefault_GenericDeserializer_693116719_1739184158.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadEnumDefault_GenericDeserializer_693116719_1739184158.java @@ -7,6 +7,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.AvroTypeException; import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; @@ -58,6 +62,7 @@ public FastGenericDeserializerGeneratorTest_shouldReadEnumDefault_GenericDeseria this.enumMappingtestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -65,6 +70,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadEnumDefault0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadEnumDefault0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadEnumDefault0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnumDefault; @@ -86,12 +100,21 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadE } } FastGenericDeserializerGeneratorTest_shouldReadEnumDefault.put(0, enumValue0); +<<<<<<< HEAD populate_FastGenericDeserializerGeneratorTest_shouldReadEnumDefault0((FastGenericDeserializerGeneratorTest_shouldReadEnumDefault), (decoder)); populate_FastGenericDeserializerGeneratorTest_shouldReadEnumDefault1((FastGenericDeserializerGeneratorTest_shouldReadEnumDefault), (decoder)); return FastGenericDeserializerGeneratorTest_shouldReadEnumDefault; } private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnumDefault0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnumDefault, Decoder decoder) +======= + populate_FastGenericDeserializerGeneratorTest_shouldReadEnumDefault0((FastGenericDeserializerGeneratorTest_shouldReadEnumDefault), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnumDefault1((FastGenericDeserializerGeneratorTest_shouldReadEnumDefault), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadEnumDefault; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnumDefault0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnumDefault, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -151,7 +174,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnumDefault FastGenericDeserializerGeneratorTest_shouldReadEnumDefault.put(2, testEnumArray1); } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnumDefault1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnumDefault, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnumDefault1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnumDefault, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testEnumUnionArray1 = null; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java index 1a3daa824..5b6427344 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.generic.GenericEnumSymbol; @@ -30,6 +34,7 @@ public FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_6 this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -37,6 +42,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum; @@ -46,12 +60,21 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadE FastGenericDeserializerGeneratorTest_shouldReadEnum = new org.apache.avro.generic.GenericData.Record(readerSchema); } FastGenericDeserializerGeneratorTest_shouldReadEnum.put(0, new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get((decoder.readEnum())))); +<<<<<<< HEAD populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0((FastGenericDeserializerGeneratorTest_shouldReadEnum), (decoder)); populate_FastGenericDeserializerGeneratorTest_shouldReadEnum1((FastGenericDeserializerGeneratorTest_shouldReadEnum), (decoder)); return FastGenericDeserializerGeneratorTest_shouldReadEnum; } private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum, Decoder decoder) +======= + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum1((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -87,7 +110,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0(Index FastGenericDeserializerGeneratorTest_shouldReadEnum.put(2, testEnumArray1); } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnum1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnum1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testEnumUnionArray1 = null; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadFixed_GenericDeserializer_1590965143_1590965143.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadFixed_GenericDeserializer_1590965143_1590965143.java index 9c72ec426..12c085c18 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadFixed_GenericDeserializer_1590965143_1590965143.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadFixed_GenericDeserializer_1590965143_1590965143.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.generic.GenericFixed; @@ -30,6 +34,7 @@ public FastGenericDeserializerGeneratorTest_shouldReadFixed_GenericDeserializer_ this.testFixedUnionArrayArrayElemSchema0 = testFixedUnionArray0 .getElementType(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -37,6 +42,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed; @@ -54,12 +68,21 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadF } decoder.readFixed(testFixed1); FastGenericDeserializerGeneratorTest_shouldReadFixed.put(0, new org.apache.avro.generic.GenericData.Fixed(testFixed0, testFixed1)); +<<<<<<< HEAD populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0((FastGenericDeserializerGeneratorTest_shouldReadFixed), (decoder)); populate_FastGenericDeserializerGeneratorTest_shouldReadFixed1((FastGenericDeserializerGeneratorTest_shouldReadFixed), (decoder)); return FastGenericDeserializerGeneratorTest_shouldReadFixed; } private void populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed, Decoder decoder) +======= + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed1((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadFixed; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -115,7 +138,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0(Inde FastGenericDeserializerGeneratorTest_shouldReadFixed.put(2, testFixedArray1); } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadFixed1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadFixed1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testFixedUnionArray1 = null; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion_GenericDeserializer_2643982_2643982.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion_GenericDeserializer_2643982_2643982.java index 9a6bf56b3..dc6ef67c6 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion_GenericDeserializer_2643982_2643982.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion_GenericDeserializer_2643982_2643982.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -24,6 +28,7 @@ public FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion_Generi this.subField0 = unionOptionSchema0 .getField("subField").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -31,6 +36,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; @@ -45,7 +59,11 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadM FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, null); } else { if (unionIndex0 == 1) { +<<<<<<< HEAD FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0), (decoder))); +======= + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { if (unionIndex0 == 2) { Utf8 charSequence1; @@ -68,7 +86,11 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadM return FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; } +<<<<<<< HEAD public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java index 6ba24cae2..451da39aa 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java @@ -7,6 +7,10 @@ import java.util.Map; import com.linkedin.avro.api.PrimitiveIntList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -29,6 +33,7 @@ public FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeseriali this.mapFieldValueMapValueSchema0 = mapFieldMapValueSchema0 .getValueType(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -36,6 +41,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadNestedMap; @@ -47,6 +61,7 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadN Map>> mapField1 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map>> mapFieldReuse0 = null; Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0); if (oldMap0 instanceof Map) { @@ -57,6 +72,22 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadN mapField1 = mapFieldReuse0; } else { mapField1 = new HashMap>>(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), ((int) chunkLen0))); + } else { + Map>> mapFieldReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0); + if (oldMap0 instanceof Map) { + mapFieldReuse0 = ((Map) oldMap0); + } + if (mapFieldReuse0 != (null)) { + mapFieldReuse0 .clear(); + mapField1 = mapFieldReuse0; + } else { + mapField1 = new HashMap>>(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 > mapFieldValue0 = null; long chunkLen1 = (decoder.readMapStart()); if (chunkLen1 > 0) { +<<<<<<< HEAD Map> mapFieldValueReuse0 = null; if (null instanceof Map) { mapFieldValueReuse0 = ((Map) null); @@ -73,6 +105,21 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadN mapFieldValue0 = mapFieldValueReuse0; } else { mapFieldValue0 = new HashMap>(((int)(((chunkLen1 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, ((int) chunkLen1))); + } else { + Map> mapFieldValueReuse0 = null; + if (null instanceof Map) { + mapFieldValueReuse0 = ((Map) null); + } + if (mapFieldValueReuse0 != (null)) { + mapFieldValueReuse0 .clear(); + mapFieldValue0 = mapFieldValueReuse0; + } else { + mapFieldValue0 = new HashMap>(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter1 = 0; (counter1 0); } else { +<<<<<<< HEAD mapFieldValue0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, 0)); + } else { + mapFieldValue0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } mapField1 .put(key0, mapFieldValue0); } chunkLen0 = (decoder.mapNext()); } while (chunkLen0 > 0); } else { +<<<<<<< HEAD mapField1 = new HashMap>>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), 0)); + } else { + mapField1 = new HashMap>>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastGenericDeserializerGeneratorTest_shouldReadNestedMap.put(0, mapField1); return FastGenericDeserializerGeneratorTest_shouldReadNestedMap; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java index 3dd52ee5f..97343d17d 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java @@ -7,6 +7,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.AvroTypeException; import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; @@ -66,6 +70,7 @@ public FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDese this.enumMappingtestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -73,6 +78,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; @@ -94,12 +108,21 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadP } } FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(0, enumValue0); +<<<<<<< HEAD populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (decoder)); populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum1((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (decoder)); return FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; } private void populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum, Decoder decoder) +======= + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum1((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -159,7 +182,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedE FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(2, testEnumArray1); } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testEnumUnionArray1 = null; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadPrimitives_GenericDeserializer_1966544736_1966544736.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadPrimitives_GenericDeserializer_1966544736_1966544736.java index d282cf38a..2308e8f99 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadPrimitives_GenericDeserializer_1966544736_1966544736.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadPrimitives_GenericDeserializer_1966544736_1966544736.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.nio.ByteBuffer; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -33,6 +37,7 @@ public FastGenericDeserializerGeneratorTest_shouldReadPrimitives_GenericDeserial this.testBytesUnion0 = readerSchema.getField("testBytesUnion").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -40,6 +45,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives; @@ -49,6 +63,7 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadP FastGenericDeserializerGeneratorTest_shouldReadPrimitives = new org.apache.avro.generic.GenericData.Record(readerSchema); } FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(0, (decoder.readInt())); +<<<<<<< HEAD populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (decoder)); populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (decoder)); populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (decoder)); @@ -60,6 +75,19 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadP } private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, Decoder decoder) +======= + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPrimitives; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -83,7 +111,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0 FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(2, charSequence0); } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex1 = (decoder.readIndex()); @@ -107,7 +139,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1 FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(4, (decoder.readLong())); } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex2 = (decoder.readIndex()); @@ -124,7 +160,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2 FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(6, (decoder.readDouble())); } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); @@ -141,7 +181,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3 FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(8, (decoder.readFloat())); } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex4 = (decoder.readIndex()); @@ -158,7 +202,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4 FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(10, (decoder.readBoolean())); } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex5 = (decoder.readIndex()); @@ -182,7 +230,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5 FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(12, byteBuffer0); } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex6 = (decoder.readIndex()); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java index 3d5b7735d..f7a868808 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.generic.IndexedRecord; @@ -32,6 +36,7 @@ public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecor this.recordArray0 = readerSchema.getField("recordArray").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -39,6 +44,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; @@ -47,12 +61,21 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadS } else { FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); } +<<<<<<< HEAD FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder))); populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (decoder)); return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; } public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) +======= + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord; @@ -83,10 +106,17 @@ public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) return subRecord; } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, Decoder decoder) throws IOException { FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord1(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder))); +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord1(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) List recordArray1 = null; long chunkLen0 = (decoder.readArrayStart()); Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); @@ -106,14 +136,22 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAnd if (oldArray0 instanceof GenericArray) { recordArrayArrayElementReuseVar0 = ((GenericArray) oldArray0).peek(); } +<<<<<<< HEAD recordArray1 .add(deserializesubRecord0(recordArrayArrayElementReuseVar0, (decoder))); +======= + recordArray1 .add(deserializesubRecord0(recordArrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen0 = (decoder.arrayNext()); } FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(2, recordArray1); } +<<<<<<< HEAD public IndexedRecord deserializesubRecord1(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializesubRecord1(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord; @@ -133,11 +171,19 @@ public IndexedRecord deserializesubRecord1(Object reuse, Decoder decoder) throw new RuntimeException(("Illegal union index for 'intField': "+ unionIndex1)); } } +<<<<<<< HEAD populate_subRecord0((subRecord), (decoder)); return subRecord; } private void populate_subRecord0(IndexedRecord subRecord, Decoder decoder) +======= + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex2 = (decoder.readIndex()); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1365753944_1274815349.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1365753944_1274815349.java index e84ee31ed..a3e47d4a8 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1365753944_1274815349.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1365753944_1274815349.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.generic.IndexedRecord; @@ -32,6 +36,7 @@ public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecor this.recordArray0 = readerSchema.getField("recordArray").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -39,6 +44,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; @@ -47,12 +61,21 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadS } else { FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); } +<<<<<<< HEAD FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializealiasedSubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder))); populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (decoder)); return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; } public IndexedRecord deserializealiasedSubRecord0(Object reuse, Decoder decoder) +======= + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializealiasedSubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializealiasedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord aliasedSubRecord; @@ -71,11 +94,19 @@ public IndexedRecord deserializealiasedSubRecord0(Object reuse, Decoder decoder) throw new RuntimeException(("Illegal union index for 'intField': "+ unionIndex0)); } } +<<<<<<< HEAD populate_aliasedSubRecord0((aliasedSubRecord), (decoder)); return aliasedSubRecord; } private void populate_aliasedSubRecord0(IndexedRecord aliasedSubRecord, Decoder decoder) +======= + populate_aliasedSubRecord0((aliasedSubRecord), (customization), (decoder)); + return aliasedSubRecord; + } + + private void populate_aliasedSubRecord0(IndexedRecord aliasedSubRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex1 = (decoder.readIndex()); @@ -98,10 +129,17 @@ private void populate_aliasedSubRecord0(IndexedRecord aliasedSubRecord, Decoder } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, Decoder decoder) throws IOException { FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder))); +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) List recordArray1 = null; long chunkLen0 = (decoder.readArrayStart()); Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); @@ -121,14 +159,22 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAnd if (oldArray0 instanceof GenericArray) { recordArrayArrayElementReuseVar0 = ((GenericArray) oldArray0).peek(); } +<<<<<<< HEAD recordArray1 .add(deserializealiasedSubRecord0(recordArrayArrayElementReuseVar0, (decoder))); +======= + recordArray1 .add(deserializealiasedSubRecord0(recordArrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen0 = (decoder.arrayNext()); } FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(2, recordArray1); } +<<<<<<< HEAD public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord aliasedSubRecord; @@ -148,11 +194,19 @@ public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) throw new RuntimeException(("Illegal union index for 'intField': "+ unionIndex2)); } } +<<<<<<< HEAD populate_aliasedSubRecord1((aliasedSubRecord), (decoder)); return aliasedSubRecord; } private void populate_aliasedSubRecord1(IndexedRecord aliasedSubRecord, Decoder decoder) +======= + populate_aliasedSubRecord1((aliasedSubRecord), (customization), (decoder)); + return aliasedSubRecord; + } + + private void populate_aliasedSubRecord1(IndexedRecord aliasedSubRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField_GenericDeserializer_1602399407_1602399407.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField_GenericDeserializer_1602399407_1602399407.java index 90c1028b2..94611ea07 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField_GenericDeserializer_1602399407_1602399407.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField_GenericDeserializer_1602399407_1602399407.java @@ -6,6 +6,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.generic.IndexedRecord; @@ -42,6 +46,7 @@ public FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField_ this.recordsMapUnionOptionMapValueSchema0 = recordsMapUnionOptionSchema0 .getValueType(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -49,6 +54,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField; @@ -76,17 +90,30 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadS if (oldArray0 instanceof GenericArray) { recordsArrayArrayElementReuseVar0 = ((GenericArray) oldArray0).peek(); } +<<<<<<< HEAD recordsArray1 .add(deserializesubRecord0(recordsArrayArrayElementReuseVar0, (decoder))); +======= + recordsArray1 .add(deserializesubRecord0(recordsArrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen0 = (decoder.arrayNext()); } FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(0, recordsArray1); +<<<<<<< HEAD populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField), (decoder)); populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField1((FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField), (decoder)); return FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField; } public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) +======= + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField1((FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord; @@ -116,12 +143,17 @@ public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) return subRecord; } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map recordsMap1 = null; long chunkLen1 = (decoder.readMapStart()); if (chunkLen1 > 0) { +<<<<<<< HEAD Map recordsMapReuse0 = null; Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1); if (oldMap0 instanceof Map) { @@ -132,16 +164,44 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCo recordsMap1 = recordsMapReuse0; } else { recordsMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), ((int) chunkLen1))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap1 = recordsMapReuse0; + } else { + recordsMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter1 = 0; (counter1 >>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen1 = (decoder.mapNext()); } while (chunkLen1 > 0); } else { +<<<<<<< HEAD recordsMap1 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), 0)); + } else { + recordsMap1 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(1, recordsMap1); int unionIndex1 = (decoder.readIndex()); @@ -175,7 +235,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCo recordsArrayUnionOption0 .add(null); } else { if (unionIndex2 == 1) { +<<<<<<< HEAD recordsArrayUnionOption0 .add(deserializesubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder))); +======= + recordsArrayUnionOption0 .add(deserializesubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayUnionOptionElem': "+ unionIndex2)); } @@ -190,7 +254,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCo } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); @@ -202,6 +270,7 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCo Map recordsMapUnionOption0 = null; long chunkLen3 = (decoder.readMapStart()); if (chunkLen3 > 0) { +<<<<<<< HEAD Map recordsMapUnionOptionReuse0 = null; Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3); if (oldMap1 instanceof Map) { @@ -212,6 +281,22 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCo recordsMapUnionOption0 = recordsMapUnionOptionReuse0; } else { recordsMapUnionOption0 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), ((int) chunkLen3))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter3 = 0; (counter3 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapUnionOptionValue': "+ unionIndex4)); } @@ -231,7 +320,15 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCo chunkLen3 = (decoder.mapNext()); } while (chunkLen3 > 0); } else { +<<<<<<< HEAD recordsMapUnionOption0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(3, recordsMapUnionOption0); } else { diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java index 48996fc1e..2a1c59d47 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java @@ -6,6 +6,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.generic.IndexedRecord; @@ -50,6 +54,7 @@ public FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollection this.recordsMapArrayUnionOptionValueArrayElemSchema0 = recordsMapArrayMapValueSchema0 .getElementType(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -57,6 +62,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; @@ -87,6 +101,7 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadS Map recordsArrayMapElem0 = null; long chunkLen1 = (decoder.readMapStart()); if (chunkLen1 > 0) { +<<<<<<< HEAD Map recordsArrayMapElemReuse0 = null; if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); @@ -96,6 +111,21 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadS recordsArrayMapElem0 = recordsArrayMapElemReuse0; } else { recordsArrayMapElem0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen1))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter1 = 0; (counter1 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapElemValue': "+ unionIndex0)); } @@ -115,19 +149,36 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadS chunkLen1 = (decoder.mapNext()); } while (chunkLen1 > 0); } else { +<<<<<<< HEAD recordsArrayMapElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMap1 .add(recordsArrayMapElem0); } chunkLen0 = (decoder.arrayNext()); } FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(0, recordsArrayMap1); +<<<<<<< HEAD populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (decoder)); populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (decoder)); return FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; } public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) +======= + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord; @@ -157,12 +208,17 @@ public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) return subRecord; } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map> recordsMapArray1 = null; long chunkLen2 = (decoder.readMapStart()); if (chunkLen2 > 0) { +<<<<<<< HEAD Map> recordsMapArrayReuse0 = null; Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1); if (oldMap0 instanceof Map) { @@ -173,6 +229,22 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCo recordsMapArray1 = recordsMapArrayReuse0; } else { recordsMapArray1 = new HashMap>(((int)(((chunkLen2 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), ((int) chunkLen2))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap0); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray1 = recordsMapArrayReuse0; + } else { + recordsMapArray1 = new HashMap>(((int)(((chunkLen2 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter2 = 0; (counter2 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayValueElem': "+ unionIndex2)); } @@ -214,7 +290,15 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCo chunkLen2 = (decoder.mapNext()); } while (chunkLen2 > 0); } else { +<<<<<<< HEAD recordsMapArray1 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), 0)); + } else { + recordsMapArray1 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(1, recordsMapArray1); int unionIndex3 = (decoder.readIndex()); @@ -245,6 +329,7 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCo Map recordsArrayMapUnionOptionElem0 = null; long chunkLen5 = (decoder.readMapStart()); if (chunkLen5 > 0) { +<<<<<<< HEAD Map recordsArrayMapUnionOptionElemReuse0 = null; if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); @@ -254,6 +339,21 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCo recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; } else { recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen5))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter5 = 0; (counter5 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnionOptionElemValue': "+ unionIndex4)); } @@ -273,7 +377,15 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCo chunkLen5 = (decoder.mapNext()); } while (chunkLen5 > 0); } else { +<<<<<<< HEAD recordsArrayMapUnionOptionElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); } @@ -286,7 +398,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCo } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex5 = (decoder.readIndex()); @@ -298,6 +414,7 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCo Map> recordsMapArrayUnionOption0 = null; long chunkLen6 = (decoder.readMapStart()); if (chunkLen6 > 0) { +<<<<<<< HEAD Map> recordsMapArrayUnionOptionReuse0 = null; Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3); if (oldMap1 instanceof Map) { @@ -308,6 +425,22 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCo recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; } else { recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen6 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), ((int) chunkLen6))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter6 = 0; (counter6 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnionOptionValueElem': "+ unionIndex6)); } @@ -349,7 +486,15 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordCo chunkLen6 = (decoder.mapNext()); } while (chunkLen6 > 0); } else { +<<<<<<< HEAD recordsMapArrayUnionOption0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(3, recordsMapArrayUnionOption0); } else { diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java index 0f99a572f..ed7280bb2 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -26,6 +30,7 @@ public FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDese this.field0 = readerSchema.getField("field").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -33,6 +38,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; @@ -47,16 +61,28 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadS FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, null); } else { if (unionIndex0 == 1) { +<<<<<<< HEAD FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(0), (decoder))); +======= + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(0), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'record': "+ unionIndex0)); } } +<<<<<<< HEAD populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordField), (decoder)); return FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; } public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) +======= + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord; @@ -86,10 +112,17 @@ public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) return subRecord; } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField, Decoder decoder) throws IOException { FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(1), (decoder))); +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(1), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) int unionIndex2 = (decoder.readIndex()); if (unionIndex2 == 0) { decoder.readNull(); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java index b182d68f0..fe80ec8b6 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java @@ -6,6 +6,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.generic.IndexedRecord; @@ -38,6 +42,7 @@ public FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeseri this.subRecordArray0 = readerSchema.getField("subRecordArray").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -45,6 +50,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; @@ -71,6 +85,7 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipR throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex0)); } } +<<<<<<< HEAD populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (decoder)); populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (decoder)); populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (decoder)); @@ -78,6 +93,15 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipR } private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, Decoder decoder) +======= + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex1 = (decoder.readIndex()); @@ -110,7 +134,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedFiel } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); @@ -119,7 +147,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedFiel FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, null); } else { if (unionIndex3 == 1) { +<<<<<<< HEAD FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(2), (decoder))); +======= + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(2), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex3)); } @@ -127,6 +159,7 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedFiel Map subRecordMap1 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map subRecordMapReuse0 = null; Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3); if (oldMap0 instanceof Map) { @@ -137,21 +170,53 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedFiel subRecordMap1 = subRecordMapReuse0; } else { subRecordMap1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), ((int) chunkLen0))); + } else { + Map subRecordMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3); + if (oldMap0 instanceof Map) { + subRecordMapReuse0 = ((Map) oldMap0); + } + if (subRecordMapReuse0 != (null)) { + subRecordMapReuse0 .clear(); + subRecordMap1 = subRecordMapReuse0; + } else { + subRecordMap1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 >>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen0 = (decoder.mapNext()); } while (chunkLen0 > 0); } else { +<<<<<<< HEAD subRecordMap1 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), 0)); + } else { + subRecordMap1 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(3, subRecordMap1); } +<<<<<<< HEAD public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord; @@ -178,11 +243,19 @@ public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex4)); } } +<<<<<<< HEAD populate_subRecord0((subRecord), (decoder)); return subRecord; } private void populate_subRecord0(IndexedRecord subRecord, Decoder decoder) +======= + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex5 = (decoder.readIndex()); @@ -215,7 +288,11 @@ private void populate_subRecord0(IndexedRecord subRecord, Decoder decoder) } } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, Decoder decoder) +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List subRecordArray1 = null; @@ -237,7 +314,11 @@ private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedFiel if (oldArray0 instanceof GenericArray) { subRecordArrayArrayElementReuseVar0 = ((GenericArray) oldArray0).peek(); } +<<<<<<< HEAD subRecordArray1 .add(deserializesubRecord0(subRecordArrayArrayElementReuseVar0, (decoder))); +======= + subRecordArray1 .add(deserializesubRecord0(subRecordArrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen1 = (decoder.arrayNext()); } diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord_GenericDeserializer_1090641932_438987109.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord_GenericDeserializer_1090641932_438987109.java index a3b080ec2..4d2c487d9 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord_GenericDeserializer_1090641932_438987109.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord_GenericDeserializer_1090641932_438987109.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -20,6 +24,7 @@ public FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord_Generi this.subRecord0 = readerSchema.getField("subRecord").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -27,6 +32,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; @@ -35,11 +49,19 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipR } else { FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); } +<<<<<<< HEAD FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.get(0), (decoder))); return FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; } public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) +======= + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.get(0), (decoder), (customization))); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord; @@ -56,6 +78,7 @@ public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) charSequence0 = (decoder).readString(null); } subRecord.put(0, charSequence0); +<<<<<<< HEAD populate_subRecord0((subRecord), (decoder)); populate_subRecord1((subRecord), (decoder)); return subRecord; @@ -65,19 +88,38 @@ private void populate_subRecord0(IndexedRecord subRecord, Decoder decoder) throws IOException { deserializesubSubRecord0(null, (decoder)); +======= + populate_subRecord0((subRecord), (customization), (decoder)); + populate_subRecord1((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubSubRecord0(null, (decoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) int unionIndex0 = (decoder.readIndex()); if (unionIndex0 == 0) { decoder.readNull(); } else { if (unionIndex0 == 1) { +<<<<<<< HEAD deserializesubSubRecord0(null, (decoder)); +======= + deserializesubSubRecord0(null, (decoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'test3': "+ unionIndex0)); } } } +<<<<<<< HEAD public void deserializesubSubRecord0(Object reuse, Decoder decoder) +======= + public void deserializesubSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { decoder.skipString(); @@ -90,7 +132,11 @@ private void populate_subSubRecord0(Decoder decoder) decoder.skipString(); } +<<<<<<< HEAD private void populate_subRecord1(IndexedRecord subRecord, Decoder decoder) +======= + private void populate_subRecord1(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Utf8 charSequence1; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java index 1dbe788a8..363407c56 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -20,6 +24,7 @@ public FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeser this.subRecord10 = readerSchema.getField("subRecord1").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -27,6 +32,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; @@ -35,6 +49,7 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipR } else { FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); } +<<<<<<< HEAD FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(0), (decoder))); populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (decoder)); populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (decoder)); @@ -42,6 +57,15 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipR } public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) +======= + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord; @@ -58,11 +82,19 @@ public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) charSequence0 = (decoder).readString(null); } subRecord.put(0, charSequence0); +<<<<<<< HEAD populate_subRecord0((subRecord), (decoder)); return subRecord; } private void populate_subRecord0(IndexedRecord subRecord, Decoder decoder) +======= + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Utf8 charSequence1; @@ -75,23 +107,38 @@ private void populate_subRecord0(IndexedRecord subRecord, Decoder decoder) subRecord.put(1, charSequence1); } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, Decoder decoder) throws IOException { deserializesubRecord20(null, (decoder)); +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubRecord20(null, (decoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) int unionIndex0 = (decoder.readIndex()); if (unionIndex0 == 0) { decoder.readNull(); } else { if (unionIndex0 == 1) { +<<<<<<< HEAD deserializesubRecord20(null, (decoder)); +======= + deserializesubRecord20(null, (decoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'subRecord3': "+ unionIndex0)); } } } +<<<<<<< HEAD public void deserializesubRecord20(Object reuse, Decoder decoder) +======= + public void deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { decoder.skipString(); @@ -104,10 +151,17 @@ private void populate_subRecord20(Decoder decoder) decoder.skipString(); } +<<<<<<< HEAD private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, Decoder decoder) throws IOException { FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(1), (decoder))); +======= + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(1), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } } diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java index 40ce3a8f4..375a59539 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -20,6 +24,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroW this.test0 = readerSchema.getField("test").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -27,6 +32,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java index dcbf3aaa9..85e412266 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -20,6 +24,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroW this.test0 = readerSchema.getField("test").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -27,6 +32,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java index a841e7942..a514374ad 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.AvroTypeException; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -21,6 +25,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroW this.test0 = readerSchema.getField("test").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -28,6 +33,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java index 4adcd2f6a..836abfa16 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -20,6 +24,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroW this.test0 = readerSchema.getField("test").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -27,6 +32,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java index b5db9075a..63362ac42 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -20,6 +24,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatInc this.test0 = readerSchema.getField("test").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -27,6 +32,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java index 4bd5a62ec..a5bf3b963 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -20,6 +24,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatInc this.test0 = readerSchema.getField("test").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -27,6 +32,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java index 3f462b93c..07d7842f7 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -20,6 +24,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatInc this.test0 = readerSchema.getField("test").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -27,6 +32,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java index 6d0e1eeba..3b0a82784 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -20,6 +24,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatInc this.test0 = readerSchema.getField("test").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -27,6 +32,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java index b929b35ca..90a943fc5 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java @@ -4,6 +4,10 @@ import java.io.IOException; import com.linkedin.avro.api.PrimitiveIntList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -23,6 +27,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArr this.testOptionSchema0 = test0 .getTypes().get(0); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -30,6 +35,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_906204958.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_906204958.java index 2ad99bbcf..fcddcf865 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_906204958.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_906204958.java @@ -4,6 +4,10 @@ import java.io.IOException; import com.linkedin.avro.api.PrimitiveIntList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -23,6 +27,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArr this.testOptionSchema0 = test0 .getTypes().get(1); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -30,6 +35,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_1778260273.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_1778260273.java index c45ea3074..9098d8a03 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_1778260273.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_1778260273.java @@ -4,6 +4,10 @@ import java.io.IOException; import com.linkedin.avro.api.PrimitiveIntList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -23,6 +27,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArr this.testOptionSchema0 = test0 .getTypes().get(0); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -30,6 +35,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_906204958.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_906204958.java index f7f8ff362..7fb19c840 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_906204958.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_906204958.java @@ -4,6 +4,10 @@ import java.io.IOException; import com.linkedin.avro.api.PrimitiveIntList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -23,6 +27,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArr this.testOptionSchema0 = test0 .getTypes().get(1); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -30,6 +35,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_2127585735.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_2127585735.java index 38eca98bb..4bffbdc62 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_2127585735.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_2127585735.java @@ -5,6 +5,10 @@ import java.util.HashMap; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -24,6 +28,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMap this.testOptionSchema0 = test0 .getTypes().get(0); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -31,6 +36,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; @@ -44,6 +58,7 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler Map testOption0 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map testOptionReuse0 = null; Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); if (oldMap0 instanceof Map) { @@ -54,6 +69,22 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler testOption0 = testOptionReuse0; } else { testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 0); } else { +<<<<<<< HEAD testOption0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); } else { diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java index ab3e738c1..b98347eb4 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java @@ -5,6 +5,10 @@ import java.util.HashMap; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -24,6 +28,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMap this.testOptionSchema0 = test0 .getTypes().get(1); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -31,6 +36,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; @@ -44,6 +58,7 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler Map testOption0 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map testOptionReuse0 = null; Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); if (oldMap0 instanceof Map) { @@ -54,6 +69,22 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler testOption0 = testOptionReuse0; } else { testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 0); } else { +<<<<<<< HEAD testOption0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); } else { diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java index 24afa6132..cc69512c9 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java @@ -5,6 +5,10 @@ import java.util.HashMap; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -24,6 +28,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMap this.testOptionSchema0 = test0 .getTypes().get(0); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -31,6 +36,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; @@ -48,6 +62,7 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler Map testOption0 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map testOptionReuse0 = null; Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); if (oldMap0 instanceof Map) { @@ -58,6 +73,22 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler testOption0 = testOptionReuse0; } else { testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 0); } else { +<<<<<<< HEAD testOption0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); } else { diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java index d8f33bee4..8c849566f 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java @@ -5,6 +5,10 @@ import java.util.HashMap; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -24,6 +28,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMap this.testOptionSchema0 = test0 .getTypes().get(1); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -31,6 +36,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; @@ -48,6 +62,7 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler Map testOption0 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map testOptionReuse0 = null; Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); if (oldMap0 instanceof Map) { @@ -58,6 +73,22 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler testOption0 = testOptionReuse0; } else { testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 0); } else { +<<<<<<< HEAD testOption0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); } else { diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java index dc777524f..aa31a1b9b 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -19,6 +23,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNon this.test0 = readerSchema.getField("test").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -26,6 +31,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java index 59de773cc..adefee7b7 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -19,6 +23,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNon this.test0 = readerSchema.getField("test").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -26,6 +31,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java index 1ad916d09..8f0b56556 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -19,6 +23,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNon this.test0 = readerSchema.getField("test").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -26,6 +31,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java index 619e27298..c26771e8c 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -19,6 +23,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNon this.test0 = readerSchema.getField("test").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -26,6 +31,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java index a80ceb4d9..0a2013469 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -23,6 +27,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSub this.testOptionSchema1 = test0 .getTypes().get(2); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -30,6 +35,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; @@ -44,10 +58,17 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); } else { if (unionIndex0 == 1) { +<<<<<<< HEAD FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder))); } else { if (unionIndex0 == 2) { FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder))); +======= + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); } @@ -56,7 +77,11 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; } +<<<<<<< HEAD public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord1; @@ -69,7 +94,11 @@ public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder) return subRecord1; } +<<<<<<< HEAD public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord2; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java index 0f3d81197..5d8b7651a 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -23,6 +27,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSub this.testOptionSchema1 = test0 .getTypes().get(0); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -30,6 +35,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; @@ -44,10 +58,17 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); } else { if (unionIndex0 == 1) { +<<<<<<< HEAD FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder))); } else { if (unionIndex0 == 2) { FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder))); +======= + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); } @@ -56,7 +77,11 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; } +<<<<<<< HEAD public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord1; @@ -69,7 +94,11 @@ public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder) return subRecord1; } +<<<<<<< HEAD public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord2; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java index a8492834e..436786b9e 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -23,6 +27,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSub this.testOptionSchema1 = test0 .getTypes().get(1); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -30,6 +35,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; @@ -40,10 +54,17 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler } int unionIndex0 = (decoder.readIndex()); if (unionIndex0 == 0) { +<<<<<<< HEAD FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder))); } else { if (unionIndex0 == 1) { FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder))); +======= + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { if (unionIndex0 == 2) { decoder.readNull(); @@ -56,7 +77,11 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; } +<<<<<<< HEAD public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord2; @@ -69,7 +94,11 @@ public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder) return subRecord2; } +<<<<<<< HEAD public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord1; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java index bcf251fac..310dc1568 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -23,6 +27,7 @@ public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSub this.testOptionSchema1 = test0 .getTypes().get(1); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -30,6 +35,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; @@ -40,10 +54,17 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler } int unionIndex0 = (decoder.readIndex()); if (unionIndex0 == 0) { +<<<<<<< HEAD FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder))); } else { if (unionIndex0 == 1) { FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder))); +======= + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { if (unionIndex0 == 2) { decoder.readNull(); @@ -56,7 +77,11 @@ public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldToler return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; } +<<<<<<< HEAD public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord2; @@ -69,7 +94,11 @@ public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder) return subRecord2; } +<<<<<<< HEAD public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord1; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesDefined_GenericDeserializer_229156053_229156053.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesDefined_GenericDeserializer_229156053_229156053.java index 92c7ae145..5ae0cd14a 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesDefined_GenericDeserializer_229156053_229156053.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesDefined_GenericDeserializer_229156053_229156053.java @@ -7,6 +7,10 @@ import java.time.LocalTime; import java.util.List; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Conversions; import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; @@ -41,6 +45,7 @@ public FastSerdeLogicalTypesDefined_GenericDeserializer_229156053_229156053(Sche this.arrayOfUnionOfDateAndTimestampMillisElemOptionSchema1 = arrayOfUnionOfDateAndTimestampMillisArrayElemSchema0 .getTypes().get(1); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -48,6 +53,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastSerdeLogicalTypesDefined0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesDefined0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastSerdeLogicalTypesDefined0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastSerdeLogicalTypesDefined; @@ -58,11 +72,19 @@ public IndexedRecord deserializeFastSerdeLogicalTypesDefined0(Object reuse, Deco } LocalTime convertedValue0 = ((LocalTime) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis)); FastSerdeLogicalTypesDefined.put(0, convertedValue0); +<<<<<<< HEAD populate_FastSerdeLogicalTypesDefined0((FastSerdeLogicalTypesDefined), (decoder)); return FastSerdeLogicalTypesDefined; } private void populate_FastSerdeLogicalTypesDefined0(IndexedRecord FastSerdeLogicalTypesDefined, Decoder decoder) +======= + populate_FastSerdeLogicalTypesDefined0((FastSerdeLogicalTypesDefined), (customization), (decoder)); + return FastSerdeLogicalTypesDefined; + } + + private void populate_FastSerdeLogicalTypesDefined0(IndexedRecord FastSerdeLogicalTypesDefined, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { LocalDate convertedValue1 = ((LocalDate) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date)); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesDefined_SpecificDeserializer_229156053_229156053.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesDefined_SpecificDeserializer_229156053_229156053.java index f2e24de40..09050bef8 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesDefined_SpecificDeserializer_229156053_229156053.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesDefined_SpecificDeserializer_229156053_229156053.java @@ -8,6 +8,10 @@ import java.util.ArrayList; import java.util.List; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Conversions; import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; @@ -29,6 +33,7 @@ public FastSerdeLogicalTypesDefined_SpecificDeserializer_229156053_229156053(Sch this.readerSchema = readerSchema; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined deserialize(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined reuse, Decoder decoder) throws IOException { @@ -36,6 +41,15 @@ public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined d } public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined deserializeFastSerdeLogicalTypesDefined0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined deserialize(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesDefined0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined deserializeFastSerdeLogicalTypesDefined0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined FastSerdeLogicalTypesDefined; @@ -46,11 +60,19 @@ public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined d } LocalTime convertedValue0 = ((LocalTime) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis)); FastSerdeLogicalTypesDefined.put(0, convertedValue0); +<<<<<<< HEAD populate_FastSerdeLogicalTypesDefined0((FastSerdeLogicalTypesDefined), (decoder)); return FastSerdeLogicalTypesDefined; } private void populate_FastSerdeLogicalTypesDefined0(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined FastSerdeLogicalTypesDefined, Decoder decoder) +======= + populate_FastSerdeLogicalTypesDefined0((FastSerdeLogicalTypesDefined), (customization), (decoder)); + return FastSerdeLogicalTypesDefined; + } + + private void populate_FastSerdeLogicalTypesDefined0(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined FastSerdeLogicalTypesDefined, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { LocalDate convertedValue1 = ((LocalDate) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date)); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesTest1_GenericDeserializer_1007574890_1007574890.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesTest1_GenericDeserializer_1007574890_1007574890.java index 9c4484277..8cd2a3fc3 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesTest1_GenericDeserializer_1007574890_1007574890.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesTest1_GenericDeserializer_1007574890_1007574890.java @@ -13,6 +13,10 @@ import java.util.Map; import java.util.UUID; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Conversions; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -113,6 +117,7 @@ public FastSerdeLogicalTypesTest1_GenericDeserializer_1007574890_1007574890(Sche this.unionOfDateAndLocalTimestampOptionSchema1 = unionOfDateAndLocalTimestamp0 .getTypes().get(1); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -120,6 +125,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastSerdeLogicalTypesTest10(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesTest10((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastSerdeLogicalTypesTest10(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastSerdeLogicalTypesTest1; @@ -152,6 +166,7 @@ public IndexedRecord deserializeFastSerdeLogicalTypesTest10(Object reuse, Decode Map unionOfArrayAndMapOption1 = null; long chunkLen1 = (decoder.readMapStart()); if (chunkLen1 > 0) { +<<<<<<< HEAD Map unionOfArrayAndMapOptionReuse0 = null; Object oldMap0 = FastSerdeLogicalTypesTest1 .get(0); if (oldMap0 instanceof Map) { @@ -162,6 +177,22 @@ public IndexedRecord deserializeFastSerdeLogicalTypesTest10(Object reuse, Decode unionOfArrayAndMapOption1 = unionOfArrayAndMapOptionReuse0; } else { unionOfArrayAndMapOption1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOfArrayAndMapOption1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(0), ((int) chunkLen1))); + } else { + Map unionOfArrayAndMapOptionReuse0 = null; + Object oldMap0 = FastSerdeLogicalTypesTest1 .get(0); + if (oldMap0 instanceof Map) { + unionOfArrayAndMapOptionReuse0 = ((Map) oldMap0); + } + if (unionOfArrayAndMapOptionReuse0 != (null)) { + unionOfArrayAndMapOptionReuse0 .clear(); + unionOfArrayAndMapOption1 = unionOfArrayAndMapOptionReuse0; + } else { + unionOfArrayAndMapOption1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter1 = 0; (counter1 0); } else { +<<<<<<< HEAD unionOfArrayAndMapOption1 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOfArrayAndMapOption1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(0), 0)); + } else { + unionOfArrayAndMapOption1 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastSerdeLogicalTypesTest1 .put(0, unionOfArrayAndMapOption1); } else { throw new RuntimeException(("Illegal union index for 'unionOfArrayAndMap': "+ unionIndex0)); } } +<<<<<<< HEAD populate_FastSerdeLogicalTypesTest10((FastSerdeLogicalTypesTest1), (decoder)); populate_FastSerdeLogicalTypesTest11((FastSerdeLogicalTypesTest1), (decoder)); populate_FastSerdeLogicalTypesTest12((FastSerdeLogicalTypesTest1), (decoder)); @@ -189,11 +229,24 @@ public IndexedRecord deserializeFastSerdeLogicalTypesTest10(Object reuse, Decode } private void populate_FastSerdeLogicalTypesTest10(IndexedRecord FastSerdeLogicalTypesTest1, Decoder decoder) +======= + populate_FastSerdeLogicalTypesTest10((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest11((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest12((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest13((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest14((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest15((FastSerdeLogicalTypesTest1), (customization), (decoder)); + return FastSerdeLogicalTypesTest1; + } + + private void populate_FastSerdeLogicalTypesTest10(IndexedRecord FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map mapOfUnionsOfDateAndTimestampMillis1 = null; long chunkLen2 = (decoder.readMapStart()); if (chunkLen2 > 0) { +<<<<<<< HEAD Map mapOfUnionsOfDateAndTimestampMillisReuse0 = null; Object oldMap1 = FastSerdeLogicalTypesTest1 .get(1); if (oldMap1 instanceof Map) { @@ -204,6 +257,22 @@ private void populate_FastSerdeLogicalTypesTest10(IndexedRecord FastSerdeLogical mapOfUnionsOfDateAndTimestampMillis1 = mapOfUnionsOfDateAndTimestampMillisReuse0; } else { mapOfUnionsOfDateAndTimestampMillis1 = new HashMap(((int)(((chunkLen2 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapOfUnionsOfDateAndTimestampMillis1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(1), ((int) chunkLen2))); + } else { + Map mapOfUnionsOfDateAndTimestampMillisReuse0 = null; + Object oldMap1 = FastSerdeLogicalTypesTest1 .get(1); + if (oldMap1 instanceof Map) { + mapOfUnionsOfDateAndTimestampMillisReuse0 = ((Map) oldMap1); + } + if (mapOfUnionsOfDateAndTimestampMillisReuse0 != (null)) { + mapOfUnionsOfDateAndTimestampMillisReuse0 .clear(); + mapOfUnionsOfDateAndTimestampMillis1 = mapOfUnionsOfDateAndTimestampMillisReuse0; + } else { + mapOfUnionsOfDateAndTimestampMillis1 = new HashMap(((int)(((chunkLen2 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter2 = 0; (counter2 0); } else { +<<<<<<< HEAD mapOfUnionsOfDateAndTimestampMillis1 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapOfUnionsOfDateAndTimestampMillis1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(1), 0)); + } else { + mapOfUnionsOfDateAndTimestampMillis1 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastSerdeLogicalTypesTest1 .put(1, mapOfUnionsOfDateAndTimestampMillis1); Map timestampMillisMap1 = null; long chunkLen3 = (decoder.readMapStart()); if (chunkLen3 > 0) { +<<<<<<< HEAD Map timestampMillisMapReuse0 = null; Object oldMap2 = FastSerdeLogicalTypesTest1 .get(2); if (oldMap2 instanceof Map) { @@ -240,6 +318,22 @@ private void populate_FastSerdeLogicalTypesTest10(IndexedRecord FastSerdeLogical timestampMillisMap1 = timestampMillisMapReuse0; } else { timestampMillisMap1 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + timestampMillisMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(2), ((int) chunkLen3))); + } else { + Map timestampMillisMapReuse0 = null; + Object oldMap2 = FastSerdeLogicalTypesTest1 .get(2); + if (oldMap2 instanceof Map) { + timestampMillisMapReuse0 = ((Map) oldMap2); + } + if (timestampMillisMapReuse0 != (null)) { + timestampMillisMapReuse0 .clear(); + timestampMillisMap1 = timestampMillisMapReuse0; + } else { + timestampMillisMap1 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter3 = 0; (counter3 0); } else { +<<<<<<< HEAD timestampMillisMap1 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + timestampMillisMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(2), 0)); + } else { + timestampMillisMap1 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastSerdeLogicalTypesTest1 .put(2, timestampMillisMap1); } +<<<<<<< HEAD private void populate_FastSerdeLogicalTypesTest11(IndexedRecord FastSerdeLogicalTypesTest1, Decoder decoder) +======= + private void populate_FastSerdeLogicalTypesTest11(IndexedRecord FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex2 = (decoder.readIndex()); @@ -304,7 +410,11 @@ private void populate_FastSerdeLogicalTypesTest11(IndexedRecord FastSerdeLogical FastSerdeLogicalTypesTest1 .put(4, arrayOfDates0); } +<<<<<<< HEAD private void populate_FastSerdeLogicalTypesTest12(IndexedRecord FastSerdeLogicalTypesTest1, Decoder decoder) +======= + private void populate_FastSerdeLogicalTypesTest12(IndexedRecord FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); @@ -337,7 +447,11 @@ private void populate_FastSerdeLogicalTypesTest12(IndexedRecord FastSerdeLogical FastSerdeLogicalTypesTest1 .put(6, convertedValue9); } +<<<<<<< HEAD private void populate_FastSerdeLogicalTypesTest13(IndexedRecord FastSerdeLogicalTypesTest1, Decoder decoder) +======= + private void populate_FastSerdeLogicalTypesTest13(IndexedRecord FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Instant convertedValue10 = ((Instant) Conversions.convertToLogicalType((decoder.readLong()), this.logicalTypeSchema_1074306973, this.logicalTypeSchema_1074306973 .getLogicalType(), this.conversion_timestamp_millis)); @@ -346,7 +460,11 @@ private void populate_FastSerdeLogicalTypesTest13(IndexedRecord FastSerdeLogical FastSerdeLogicalTypesTest1 .put(8, convertedValue11); } +<<<<<<< HEAD private void populate_FastSerdeLogicalTypesTest14(IndexedRecord FastSerdeLogicalTypesTest1, Decoder decoder) +======= + private void populate_FastSerdeLogicalTypesTest14(IndexedRecord FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { LocalTime convertedValue12 = ((LocalTime) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis)); @@ -355,15 +473,26 @@ private void populate_FastSerdeLogicalTypesTest14(IndexedRecord FastSerdeLogical FastSerdeLogicalTypesTest1 .put(10, convertedValue13); } +<<<<<<< HEAD private void populate_FastSerdeLogicalTypesTest15(IndexedRecord FastSerdeLogicalTypesTest1, Decoder decoder) +======= + private void populate_FastSerdeLogicalTypesTest15(IndexedRecord FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { LocalDate convertedValue14 = ((LocalDate) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date)); FastSerdeLogicalTypesTest1 .put(11, convertedValue14); +<<<<<<< HEAD FastSerdeLogicalTypesTest1 .put(12, deserializeLocalTimestampRecord0(FastSerdeLogicalTypesTest1 .get(12), (decoder))); } public IndexedRecord deserializeLocalTimestampRecord0(Object reuse, Decoder decoder) +======= + FastSerdeLogicalTypesTest1 .put(12, deserializeLocalTimestampRecord0(FastSerdeLogicalTypesTest1 .get(12), (decoder), (customization))); + } + + public IndexedRecord deserializeLocalTimestampRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord LocalTimestampRecord; @@ -374,12 +503,21 @@ public IndexedRecord deserializeLocalTimestampRecord0(Object reuse, Decoder deco } LocalDateTime convertedValue15 = ((LocalDateTime) Conversions.convertToLogicalType((decoder.readLong()), this.logicalTypeSchema__250645780, this.logicalTypeSchema__250645780 .getLogicalType(), this.conversion_local_timestamp_millis)); LocalTimestampRecord.put(0, convertedValue15); +<<<<<<< HEAD populate_LocalTimestampRecord0((LocalTimestampRecord), (decoder)); populate_LocalTimestampRecord1((LocalTimestampRecord), (decoder)); return LocalTimestampRecord; } private void populate_LocalTimestampRecord0(IndexedRecord LocalTimestampRecord, Decoder decoder) +======= + populate_LocalTimestampRecord0((LocalTimestampRecord), (customization), (decoder)); + populate_LocalTimestampRecord1((LocalTimestampRecord), (customization), (decoder)); + return LocalTimestampRecord; + } + + private void populate_LocalTimestampRecord0(IndexedRecord LocalTimestampRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex4 = (decoder.readIndex()); @@ -413,7 +551,11 @@ private void populate_LocalTimestampRecord0(IndexedRecord LocalTimestampRecord, } } +<<<<<<< HEAD private void populate_LocalTimestampRecord1(IndexedRecord LocalTimestampRecord, Decoder decoder) +======= + private void populate_LocalTimestampRecord1(IndexedRecord LocalTimestampRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex6 = (decoder.readIndex()); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesTest1_SpecificDeserializer_1007574890_1007574890.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesTest1_SpecificDeserializer_1007574890_1007574890.java index 6a1f80d32..bcd499f9c 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesTest1_SpecificDeserializer_1007574890_1007574890.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesTest1_SpecificDeserializer_1007574890_1007574890.java @@ -14,6 +14,10 @@ import java.util.Map; import java.util.UUID; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Conversions; import org.apache.avro.Schema; import org.apache.avro.io.Decoder; @@ -45,6 +49,7 @@ public FastSerdeLogicalTypesTest1_SpecificDeserializer_1007574890_1007574890(Sch this.readerSchema = readerSchema; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 deserialize(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 reuse, Decoder decoder) throws IOException { @@ -52,6 +57,15 @@ public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 des } public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 deserializeFastSerdeLogicalTypesTest10(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 deserialize(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesTest10((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 deserializeFastSerdeLogicalTypesTest10(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1; @@ -84,6 +98,7 @@ public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 des Map unionOfArrayAndMapOption1 = null; long chunkLen1 = (decoder.readMapStart()); if (chunkLen1 > 0) { +<<<<<<< HEAD Map unionOfArrayAndMapOptionReuse0 = null; Object oldMap0 = FastSerdeLogicalTypesTest1 .get(0); if (oldMap0 instanceof Map) { @@ -94,6 +109,22 @@ public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 des unionOfArrayAndMapOption1 = unionOfArrayAndMapOptionReuse0; } else { unionOfArrayAndMapOption1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOfArrayAndMapOption1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(0), ((int) chunkLen1))); + } else { + Map unionOfArrayAndMapOptionReuse0 = null; + Object oldMap0 = FastSerdeLogicalTypesTest1 .get(0); + if (oldMap0 instanceof Map) { + unionOfArrayAndMapOptionReuse0 = ((Map) oldMap0); + } + if (unionOfArrayAndMapOptionReuse0 != (null)) { + unionOfArrayAndMapOptionReuse0 .clear(); + unionOfArrayAndMapOption1 = unionOfArrayAndMapOptionReuse0; + } else { + unionOfArrayAndMapOption1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter1 = 0; (counter1 0); } else { +<<<<<<< HEAD unionOfArrayAndMapOption1 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOfArrayAndMapOption1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(0), 0)); + } else { + unionOfArrayAndMapOption1 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastSerdeLogicalTypesTest1 .put(0, unionOfArrayAndMapOption1); } else { throw new RuntimeException(("Illegal union index for 'unionOfArrayAndMap': "+ unionIndex0)); } } +<<<<<<< HEAD populate_FastSerdeLogicalTypesTest10((FastSerdeLogicalTypesTest1), (decoder)); populate_FastSerdeLogicalTypesTest11((FastSerdeLogicalTypesTest1), (decoder)); populate_FastSerdeLogicalTypesTest12((FastSerdeLogicalTypesTest1), (decoder)); @@ -121,11 +161,24 @@ public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 des } private void populate_FastSerdeLogicalTypesTest10(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, Decoder decoder) +======= + populate_FastSerdeLogicalTypesTest10((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest11((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest12((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest13((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest14((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest15((FastSerdeLogicalTypesTest1), (customization), (decoder)); + return FastSerdeLogicalTypesTest1; + } + + private void populate_FastSerdeLogicalTypesTest10(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map mapOfUnionsOfDateAndTimestampMillis0 = null; long chunkLen2 = (decoder.readMapStart()); if (chunkLen2 > 0) { +<<<<<<< HEAD Map mapOfUnionsOfDateAndTimestampMillisReuse0 = null; Object oldMap1 = FastSerdeLogicalTypesTest1 .get(1); if (oldMap1 instanceof Map) { @@ -136,6 +189,22 @@ private void populate_FastSerdeLogicalTypesTest10(com.linkedin.avro.fastserde.ge mapOfUnionsOfDateAndTimestampMillis0 = mapOfUnionsOfDateAndTimestampMillisReuse0; } else { mapOfUnionsOfDateAndTimestampMillis0 = new HashMap(((int)(((chunkLen2 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapOfUnionsOfDateAndTimestampMillis0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(1), ((int) chunkLen2))); + } else { + Map mapOfUnionsOfDateAndTimestampMillisReuse0 = null; + Object oldMap1 = FastSerdeLogicalTypesTest1 .get(1); + if (oldMap1 instanceof Map) { + mapOfUnionsOfDateAndTimestampMillisReuse0 = ((Map) oldMap1); + } + if (mapOfUnionsOfDateAndTimestampMillisReuse0 != (null)) { + mapOfUnionsOfDateAndTimestampMillisReuse0 .clear(); + mapOfUnionsOfDateAndTimestampMillis0 = mapOfUnionsOfDateAndTimestampMillisReuse0; + } else { + mapOfUnionsOfDateAndTimestampMillis0 = new HashMap(((int)(((chunkLen2 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter2 = 0; (counter2 0); } else { +<<<<<<< HEAD mapOfUnionsOfDateAndTimestampMillis0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapOfUnionsOfDateAndTimestampMillis0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(1), 0)); + } else { + mapOfUnionsOfDateAndTimestampMillis0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastSerdeLogicalTypesTest1 .put(1, mapOfUnionsOfDateAndTimestampMillis0); Map timestampMillisMap0 = null; long chunkLen3 = (decoder.readMapStart()); if (chunkLen3 > 0) { +<<<<<<< HEAD Map timestampMillisMapReuse0 = null; Object oldMap2 = FastSerdeLogicalTypesTest1 .get(2); if (oldMap2 instanceof Map) { @@ -172,6 +250,22 @@ private void populate_FastSerdeLogicalTypesTest10(com.linkedin.avro.fastserde.ge timestampMillisMap0 = timestampMillisMapReuse0; } else { timestampMillisMap0 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + timestampMillisMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(2), ((int) chunkLen3))); + } else { + Map timestampMillisMapReuse0 = null; + Object oldMap2 = FastSerdeLogicalTypesTest1 .get(2); + if (oldMap2 instanceof Map) { + timestampMillisMapReuse0 = ((Map) oldMap2); + } + if (timestampMillisMapReuse0 != (null)) { + timestampMillisMapReuse0 .clear(); + timestampMillisMap0 = timestampMillisMapReuse0; + } else { + timestampMillisMap0 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter3 = 0; (counter3 0); } else { +<<<<<<< HEAD timestampMillisMap0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + timestampMillisMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(2), 0)); + } else { + timestampMillisMap0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastSerdeLogicalTypesTest1 .put(2, timestampMillisMap0); } +<<<<<<< HEAD private void populate_FastSerdeLogicalTypesTest11(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, Decoder decoder) +======= + private void populate_FastSerdeLogicalTypesTest11(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex2 = (decoder.readIndex()); @@ -236,7 +342,11 @@ private void populate_FastSerdeLogicalTypesTest11(com.linkedin.avro.fastserde.ge FastSerdeLogicalTypesTest1 .put(4, arrayOfDates0); } +<<<<<<< HEAD private void populate_FastSerdeLogicalTypesTest12(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, Decoder decoder) +======= + private void populate_FastSerdeLogicalTypesTest12(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); @@ -269,7 +379,11 @@ private void populate_FastSerdeLogicalTypesTest12(com.linkedin.avro.fastserde.ge FastSerdeLogicalTypesTest1 .put(6, convertedValue9); } +<<<<<<< HEAD private void populate_FastSerdeLogicalTypesTest13(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, Decoder decoder) +======= + private void populate_FastSerdeLogicalTypesTest13(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Instant convertedValue10 = ((Instant) Conversions.convertToLogicalType((decoder.readLong()), this.logicalTypeSchema_1074306973, this.logicalTypeSchema_1074306973 .getLogicalType(), this.conversion_timestamp_millis)); @@ -278,7 +392,11 @@ private void populate_FastSerdeLogicalTypesTest13(com.linkedin.avro.fastserde.ge FastSerdeLogicalTypesTest1 .put(8, convertedValue11); } +<<<<<<< HEAD private void populate_FastSerdeLogicalTypesTest14(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, Decoder decoder) +======= + private void populate_FastSerdeLogicalTypesTest14(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { LocalTime convertedValue12 = ((LocalTime) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis)); @@ -287,15 +405,26 @@ private void populate_FastSerdeLogicalTypesTest14(com.linkedin.avro.fastserde.ge FastSerdeLogicalTypesTest1 .put(10, convertedValue13); } +<<<<<<< HEAD private void populate_FastSerdeLogicalTypesTest15(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, Decoder decoder) +======= + private void populate_FastSerdeLogicalTypesTest15(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { LocalDate convertedValue14 = ((LocalDate) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date)); FastSerdeLogicalTypesTest1 .put(11, convertedValue14); +<<<<<<< HEAD FastSerdeLogicalTypesTest1 .put(12, deserializeLocalTimestampRecord0(FastSerdeLogicalTypesTest1 .get(12), (decoder))); } public com.linkedin.avro.fastserde.generated.avro.LocalTimestampRecord deserializeLocalTimestampRecord0(Object reuse, Decoder decoder) +======= + FastSerdeLogicalTypesTest1 .put(12, deserializeLocalTimestampRecord0(FastSerdeLogicalTypesTest1 .get(12), (decoder), (customization))); + } + + public com.linkedin.avro.fastserde.generated.avro.LocalTimestampRecord deserializeLocalTimestampRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.LocalTimestampRecord LocalTimestampRecord; @@ -306,12 +435,21 @@ public com.linkedin.avro.fastserde.generated.avro.LocalTimestampRecord deseriali } LocalDateTime convertedValue15 = ((LocalDateTime) Conversions.convertToLogicalType((decoder.readLong()), this.logicalTypeSchema__250645780, this.logicalTypeSchema__250645780 .getLogicalType(), this.conversion_local_timestamp_millis)); LocalTimestampRecord.put(0, convertedValue15); +<<<<<<< HEAD populate_LocalTimestampRecord0((LocalTimestampRecord), (decoder)); populate_LocalTimestampRecord1((LocalTimestampRecord), (decoder)); return LocalTimestampRecord; } private void populate_LocalTimestampRecord0(com.linkedin.avro.fastserde.generated.avro.LocalTimestampRecord LocalTimestampRecord, Decoder decoder) +======= + populate_LocalTimestampRecord0((LocalTimestampRecord), (customization), (decoder)); + populate_LocalTimestampRecord1((LocalTimestampRecord), (customization), (decoder)); + return LocalTimestampRecord; + } + + private void populate_LocalTimestampRecord0(com.linkedin.avro.fastserde.generated.avro.LocalTimestampRecord LocalTimestampRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex4 = (decoder.readIndex()); @@ -345,7 +483,11 @@ private void populate_LocalTimestampRecord0(com.linkedin.avro.fastserde.generate } } +<<<<<<< HEAD private void populate_LocalTimestampRecord1(com.linkedin.avro.fastserde.generated.avro.LocalTimestampRecord LocalTimestampRecord, Decoder decoder) +======= + private void populate_LocalTimestampRecord1(com.linkedin.avro.fastserde.generated.avro.LocalTimestampRecord LocalTimestampRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex6 = (decoder.readIndex()); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_GenericDeserializer_1982763418_1982763418.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_GenericDeserializer_1982763418_1982763418.java index 563d4cdad..404ba053d 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_GenericDeserializer_1982763418_1982763418.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_GenericDeserializer_1982763418_1982763418.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.generic.IndexedRecord; @@ -23,6 +27,7 @@ public FastSerdeLogicalTypesUndefined_GenericDeserializer_1982763418_1982763418( this.arrayOfUnionOfDateAndTimestampMillisArrayElemSchema0 = arrayOfUnionOfDateAndTimestampMillis0 .getElementType(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -30,6 +35,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastSerdeLogicalTypesUndefined0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesUndefined0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastSerdeLogicalTypesUndefined0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastSerdeLogicalTypesUndefined; @@ -39,11 +53,19 @@ public IndexedRecord deserializeFastSerdeLogicalTypesUndefined0(Object reuse, De FastSerdeLogicalTypesUndefined = new org.apache.avro.generic.GenericData.Record(readerSchema); } FastSerdeLogicalTypesUndefined.put(0, (decoder.readInt())); +<<<<<<< HEAD populate_FastSerdeLogicalTypesUndefined0((FastSerdeLogicalTypesUndefined), (decoder)); return FastSerdeLogicalTypesUndefined; } private void populate_FastSerdeLogicalTypesUndefined0(IndexedRecord FastSerdeLogicalTypesUndefined, Decoder decoder) +======= + populate_FastSerdeLogicalTypesUndefined0((FastSerdeLogicalTypesUndefined), (customization), (decoder)); + return FastSerdeLogicalTypesUndefined; + } + + private void populate_FastSerdeLogicalTypesUndefined0(IndexedRecord FastSerdeLogicalTypesUndefined, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { FastSerdeLogicalTypesUndefined.put(1, (decoder.readInt())); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_SpecificDeserializer_1982763418_1982763418.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_SpecificDeserializer_1982763418_1982763418.java index b386cfaa2..d09a6ea5f 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_SpecificDeserializer_1982763418_1982763418.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_SpecificDeserializer_1982763418_1982763418.java @@ -5,6 +5,10 @@ import java.util.ArrayList; import java.util.List; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.io.Decoder; @@ -19,6 +23,7 @@ public FastSerdeLogicalTypesUndefined_SpecificDeserializer_1982763418_1982763418 this.readerSchema = readerSchema; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined deserialize(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined reuse, Decoder decoder) throws IOException { @@ -26,6 +31,15 @@ public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined } public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined deserializeFastSerdeLogicalTypesUndefined0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined deserialize(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesUndefined0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined deserializeFastSerdeLogicalTypesUndefined0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined FastSerdeLogicalTypesUndefined; @@ -35,11 +49,19 @@ public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined FastSerdeLogicalTypesUndefined = new com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined(); } FastSerdeLogicalTypesUndefined.put(0, (decoder.readInt())); +<<<<<<< HEAD populate_FastSerdeLogicalTypesUndefined0((FastSerdeLogicalTypesUndefined), (decoder)); return FastSerdeLogicalTypesUndefined; } private void populate_FastSerdeLogicalTypesUndefined0(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined FastSerdeLogicalTypesUndefined, Decoder decoder) +======= + populate_FastSerdeLogicalTypesUndefined0((FastSerdeLogicalTypesUndefined), (customization), (decoder)); + return FastSerdeLogicalTypesUndefined; + } + + private void populate_FastSerdeLogicalTypesUndefined0(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined FastSerdeLogicalTypesUndefined, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { FastSerdeLogicalTypesUndefined.put(1, (decoder.readInt())); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java index f9c9f4cec..c47814759 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java @@ -6,6 +6,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.generic.IndexedRecord; @@ -28,6 +32,7 @@ public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializ this.testStringMap0 = readerSchema.getField("testStringMap").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -35,6 +40,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; @@ -51,12 +65,21 @@ public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSch charSequence0 = (decoder).readString(null); } FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); +<<<<<<< HEAD populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (decoder)); populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (decoder)); return FastStringableTest_javaStringPropertyInReaderSchemaTest; } private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, Decoder decoder) +======= + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -109,12 +132,17 @@ private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(I FastStringableTest_javaStringPropertyInReaderSchemaTest.put(2, testStringArray1); } +<<<<<<< HEAD private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, Decoder decoder) +======= + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map testStringMap1 = null; long chunkLen1 = (decoder.readMapStart()); if (chunkLen1 > 0) { +<<<<<<< HEAD Map testStringMapReuse0 = null; Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); if (oldMap0 instanceof Map) { @@ -125,6 +153,22 @@ private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1(I testStringMap1 = testStringMapReuse0; } else { testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter1 = 0; (counter1 0); } else { +<<<<<<< HEAD testStringMap1 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); } diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java index 15d30a747..d96ca49f5 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java @@ -6,6 +6,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.generic.IndexedRecord; @@ -27,6 +31,7 @@ public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializ this.testStringMap0 = readerSchema.getField("testStringMap").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -34,6 +39,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; @@ -44,12 +58,21 @@ public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSch } String charSequence0 = (decoder).readString(); FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); +<<<<<<< HEAD populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (decoder)); populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (decoder)); return FastStringableTest_javaStringPropertyInReaderSchemaTest; } private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, Decoder decoder) +======= + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -91,12 +114,17 @@ private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(I FastStringableTest_javaStringPropertyInReaderSchemaTest.put(2, testStringArray1); } +<<<<<<< HEAD private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, Decoder decoder) +======= + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map testStringMap1 = null; long chunkLen1 = (decoder.readMapStart()); if (chunkLen1 > 0) { +<<<<<<< HEAD Map testStringMapReuse0 = null; Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); if (oldMap0 instanceof Map) { @@ -107,6 +135,22 @@ private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1(I testStringMap1 = testStringMapReuse0; } else { testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter1 = 0; (counter1 0); } else { +<<<<<<< HEAD testStringMap1 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); } diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java index ee0490bf6..1b6eb9c14 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java @@ -6,6 +6,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.generic.IndexedRecord; @@ -27,6 +31,7 @@ public FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_ this.testStringMap0 = readerSchema.getField("testStringMap").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -34,6 +39,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeFastStringableTest_javaStringPropertyTest0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord FastStringableTest_javaStringPropertyTest; @@ -44,12 +58,21 @@ public IndexedRecord deserializeFastStringableTest_javaStringPropertyTest0(Objec } String charSequence0 = (decoder).readString(); FastStringableTest_javaStringPropertyTest.put(0, charSequence0); +<<<<<<< HEAD populate_FastStringableTest_javaStringPropertyTest0((FastStringableTest_javaStringPropertyTest), (decoder)); populate_FastStringableTest_javaStringPropertyTest1((FastStringableTest_javaStringPropertyTest), (decoder)); return FastStringableTest_javaStringPropertyTest; } private void populate_FastStringableTest_javaStringPropertyTest0(IndexedRecord FastStringableTest_javaStringPropertyTest, Decoder decoder) +======= + populate_FastStringableTest_javaStringPropertyTest0((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyTest1((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyTest; + } + + private void populate_FastStringableTest_javaStringPropertyTest0(IndexedRecord FastStringableTest_javaStringPropertyTest, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -91,12 +114,17 @@ private void populate_FastStringableTest_javaStringPropertyTest0(IndexedRecord F FastStringableTest_javaStringPropertyTest.put(2, testStringArray1); } +<<<<<<< HEAD private void populate_FastStringableTest_javaStringPropertyTest1(IndexedRecord FastStringableTest_javaStringPropertyTest, Decoder decoder) +======= + private void populate_FastStringableTest_javaStringPropertyTest1(IndexedRecord FastStringableTest_javaStringPropertyTest, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map testStringMap1 = null; long chunkLen1 = (decoder.readMapStart()); if (chunkLen1 > 0) { +<<<<<<< HEAD Map testStringMapReuse0 = null; Object oldMap0 = FastStringableTest_javaStringPropertyTest.get(3); if (oldMap0 instanceof Map) { @@ -107,6 +135,22 @@ private void populate_FastStringableTest_javaStringPropertyTest1(IndexedRecord F testStringMap1 = testStringMapReuse0; } else { testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter1 = 0; (counter1 0); } else { +<<<<<<< HEAD testStringMap1 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } FastStringableTest_javaStringPropertyTest.put(3, testStringMap1); } diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java index 3e4b13f88..3379b8ac0 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java @@ -14,6 +14,10 @@ import com.linkedin.avro.api.PrimitiveLongList; import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.generated.avro.TestEnum; import com.linkedin.avro.fastserde.generated.avro.TestFixed; import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; @@ -37,12 +41,17 @@ public Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978(Schema reade this.readerSchema = readerSchema; } +<<<<<<< HEAD public Map deserialize(Map reuse, Decoder decoder) +======= + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map map0 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map mapReuse0 = null; if ((reuse) instanceof Map) { mapReuse0 = ((Map)(reuse)); @@ -52,21 +61,52 @@ public Map deserial map0 = mapReuse0; } else { map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 >>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen0 = (decoder.mapNext()); } while (chunkLen0 > 0); } else { +<<<<<<< HEAD map0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } return map0; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; @@ -76,6 +116,7 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); } TestRecord.put(0, (decoder.readInt())); +<<<<<<< HEAD populate_TestRecord0((TestRecord), (decoder)); populate_TestRecord1((TestRecord), (decoder)); populate_TestRecord2((TestRecord), (decoder)); @@ -99,6 +140,31 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco } private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -115,7 +181,11 @@ private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(2, (decoder.readLong())); } +<<<<<<< HEAD private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex1 = (decoder.readIndex()); @@ -132,7 +202,11 @@ private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(4, (decoder.readDouble())); } +<<<<<<< HEAD private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex2 = (decoder.readIndex()); @@ -149,7 +223,11 @@ private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(6, (decoder.readFloat())); } +<<<<<<< HEAD private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); @@ -166,7 +244,11 @@ private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(8, (decoder.readBoolean())); } +<<<<<<< HEAD private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex4 = (decoder.readIndex()); @@ -190,7 +272,11 @@ private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(10, byteBuffer0); } +<<<<<<< HEAD private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex5 = (decoder.readIndex()); @@ -221,7 +307,11 @@ private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(12, charSequence0); } +<<<<<<< HEAD private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex6 = (decoder.readIndex()); @@ -255,7 +345,11 @@ private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(14, testFixed1); } +<<<<<<< HEAD private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex7 = (decoder.readIndex()); @@ -315,7 +409,11 @@ private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(16, testFixedArray0); } +<<<<<<< HEAD private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testFixedUnionArray0 = null; @@ -365,7 +463,11 @@ private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(18, Enums.getConstant(TestEnum.class, (decoder.readEnum()))); } +<<<<<<< HEAD private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex9 = (decoder.readIndex()); @@ -401,7 +503,11 @@ private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(20, testEnumArray0); } +<<<<<<< HEAD private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testEnumUnionArray0 = null; @@ -444,14 +550,22 @@ private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(22, null); } else { if (unionIndex11 == 1) { +<<<<<<< HEAD TestRecord.put(22, deserializeSubRecord0(TestRecord.get(22), (decoder))); +======= + TestRecord.put(22, deserializeSubRecord0(TestRecord.get(22), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'subRecordUnion': "+ unionIndex11)); } } } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord; @@ -478,11 +592,19 @@ public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex12)); } } +<<<<<<< HEAD populate_SubRecord0((SubRecord), (decoder)); return SubRecord; } private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord, Decoder decoder) +======= + populate_SubRecord0((SubRecord), (customization), (decoder)); + return SubRecord; + } + + private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex13 = (decoder.readIndex()); @@ -505,10 +627,17 @@ private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubR } } +<<<<<<< HEAD private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) throws IOException { TestRecord.put(23, deserializeSubRecord0(TestRecord.get(23), (decoder))); +======= + private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + TestRecord.put(23, deserializeSubRecord0(TestRecord.get(23), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) List recordsArray0 = null; long chunkLen5 = (decoder.readArrayStart()); Object oldArray4 = TestRecord.get(24); @@ -528,19 +657,28 @@ private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.Te if (oldArray4 instanceof GenericArray) { recordsArrayArrayElementReuseVar0 = ((GenericArray) oldArray4).peek(); } +<<<<<<< HEAD recordsArray0 .add(deserializeSubRecord0(recordsArrayArrayElementReuseVar0, (decoder))); +======= + recordsArray0 .add(deserializeSubRecord0(recordsArrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen5 = (decoder.arrayNext()); } TestRecord.put(24, recordsArray0); } +<<<<<<< HEAD private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map recordsMap0 = null; long chunkLen6 = (decoder.readMapStart()); if (chunkLen6 > 0) { +<<<<<<< HEAD Map recordsMapReuse0 = null; Object oldMap0 = TestRecord.get(25); if (oldMap0 instanceof Map) { @@ -551,16 +689,44 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te recordsMap0 = recordsMapReuse0; } else { recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter6 = 0; (counter6 >>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen6 = (decoder.mapNext()); } while (chunkLen6 > 0); } else { +<<<<<<< HEAD recordsMap0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(25, recordsMap0); int unionIndex14 = (decoder.readIndex()); @@ -594,7 +760,11 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayUnionOption0 .add(null); } else { if (unionIndex15 == 1) { +<<<<<<< HEAD recordsArrayUnionOption0 .add(deserializeSubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder))); +======= + recordsArrayUnionOption0 .add(deserializeSubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayUnionOptionElem': "+ unionIndex15)); } @@ -609,7 +779,11 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex16 = (decoder.readIndex()); @@ -621,6 +795,7 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te Map recordsMapUnionOption0 = null; long chunkLen8 = (decoder.readMapStart()); if (chunkLen8 > 0) { +<<<<<<< HEAD Map recordsMapUnionOptionReuse0 = null; Object oldMap1 = TestRecord.get(27); if (oldMap1 instanceof Map) { @@ -631,6 +806,22 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te recordsMapUnionOption0 = recordsMapUnionOptionReuse0; } else { recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter8 = 0; (counter8 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapUnionOptionValue': "+ unionIndex17)); } @@ -650,7 +845,15 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te chunkLen8 = (decoder.mapNext()); } while (chunkLen8 > 0); } else { +<<<<<<< HEAD recordsMapUnionOption0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(27, recordsMapUnionOption0); } else { @@ -679,6 +882,7 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te Map recordsArrayMapElem0 = null; long chunkLen10 = (decoder.readMapStart()); if (chunkLen10 > 0) { +<<<<<<< HEAD Map recordsArrayMapElemReuse0 = null; if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); @@ -688,6 +892,21 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayMapElem0 = recordsArrayMapElemReuse0; } else { recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter10 = 0; (counter10 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapElemValue': "+ unionIndex18)); } @@ -707,7 +930,15 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te chunkLen10 = (decoder.mapNext()); } while (chunkLen10 > 0); } else { +<<<<<<< HEAD recordsArrayMapElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMap0 .add(recordsArrayMapElem0); } @@ -716,12 +947,17 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(28, recordsArrayMap0); } +<<<<<<< HEAD private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map> recordsMapArray0 = null; long chunkLen11 = (decoder.readMapStart()); if (chunkLen11 > 0) { +<<<<<<< HEAD Map> recordsMapArrayReuse0 = null; Object oldMap2 = TestRecord.get(29); if (oldMap2 instanceof Map) { @@ -732,6 +968,22 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te recordsMapArray0 = recordsMapArrayReuse0; } else { recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter11 = 0; (counter11 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayValueElem': "+ unionIndex19)); } @@ -773,7 +1029,15 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te chunkLen11 = (decoder.mapNext()); } while (chunkLen11 > 0); } else { +<<<<<<< HEAD recordsMapArray0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(29, recordsMapArray0); int unionIndex20 = (decoder.readIndex()); @@ -804,6 +1068,7 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te Map recordsArrayMapUnionOptionElem0 = null; long chunkLen14 = (decoder.readMapStart()); if (chunkLen14 > 0) { +<<<<<<< HEAD Map recordsArrayMapUnionOptionElemReuse0 = null; if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); @@ -813,6 +1078,21 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; } else { recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter14 = 0; (counter14 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnionOptionElemValue': "+ unionIndex21)); } @@ -832,7 +1116,15 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te chunkLen14 = (decoder.mapNext()); } while (chunkLen14 > 0); } else { +<<<<<<< HEAD recordsArrayMapUnionOptionElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); } @@ -845,7 +1137,11 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex22 = (decoder.readIndex()); @@ -857,6 +1153,7 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te Map> recordsMapArrayUnionOption0 = null; long chunkLen15 = (decoder.readMapStart()); if (chunkLen15 > 0) { +<<<<<<< HEAD Map> recordsMapArrayUnionOptionReuse0 = null; Object oldMap3 = TestRecord.get(31); if (oldMap3 instanceof Map) { @@ -867,6 +1164,22 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; } else { recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter15 = 0; (counter15 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnionOptionValueElem': "+ unionIndex23)); } @@ -908,7 +1225,15 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te chunkLen15 = (decoder.mapNext()); } while (chunkLen15 > 0); } else { +<<<<<<< HEAD recordsMapArrayUnionOption0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(31, recordsMapArrayUnionOption0); } else { @@ -921,7 +1246,11 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(32, null); } else { if (unionIndex24 == 1) { +<<<<<<< HEAD TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder))); +======= + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { if (unionIndex24 == 2) { Utf8 charSequence4; @@ -943,7 +1272,11 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveBooleanList booleanArray0 = null; @@ -980,7 +1313,11 @@ private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(34, doubleArray0); } +<<<<<<< HEAD private void populate_TestRecord17(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord17(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveFloatList floatArray0 = null; @@ -1004,7 +1341,11 @@ private void populate_TestRecord17(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(36, intArray0); } +<<<<<<< HEAD private void populate_TestRecord18(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord18(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveLongList longArray0 = null; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_UNION_GenericDeserializer_2140000109_2140000109.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_UNION_GenericDeserializer_2140000109_2140000109.java index fa348963d..0f57f019e 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_UNION_GenericDeserializer_2140000109_2140000109.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_UNION_GenericDeserializer_2140000109_2140000109.java @@ -5,6 +5,10 @@ import java.util.HashMap; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -26,12 +30,17 @@ public Map_of_UNION_GenericDeserializer_2140000109_2140000109(Schema readerSchem this.field0 = mapValueOptionSchema0 .getField("field").schema(); } +<<<<<<< HEAD public Map deserialize(Map reuse, Decoder decoder) +======= + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map map0 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map mapReuse0 = null; if ((reuse) instanceof Map) { mapReuse0 = ((Map)(reuse)); @@ -41,6 +50,21 @@ public Map deserialize(Map reuse, Deco map0 = mapReuse0; } else { map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 deserialize(Map reuse, Deco map0 .put(key0, null); } else { if (unionIndex0 == 1) { +<<<<<<< HEAD map0 .put(key0, deserializerecord0(null, (decoder))); +======= + map0 .put(key0, deserializerecord0(null, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'mapValue': "+ unionIndex0)); } @@ -60,12 +88,24 @@ public Map deserialize(Map reuse, Deco chunkLen0 = (decoder.mapNext()); } while (chunkLen0 > 0); } else { +<<<<<<< HEAD map0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } return map0; } +<<<<<<< HEAD public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_UNION_SpecificDeserializer_971650236_971650236.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_UNION_SpecificDeserializer_971650236_971650236.java index a03953107..2698d5ebb 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_UNION_SpecificDeserializer_971650236_971650236.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_UNION_SpecificDeserializer_971650236_971650236.java @@ -14,6 +14,10 @@ import com.linkedin.avro.api.PrimitiveLongList; import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.generated.avro.TestEnum; import com.linkedin.avro.fastserde.generated.avro.TestFixed; import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; @@ -37,12 +41,17 @@ public Map_of_UNION_SpecificDeserializer_971650236_971650236(Schema readerSchema this.readerSchema = readerSchema; } +<<<<<<< HEAD public Map deserialize(Map reuse, Decoder decoder) +======= + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map map0 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map mapReuse0 = null; if ((reuse) instanceof Map) { mapReuse0 = ((Map)(reuse)); @@ -52,6 +61,21 @@ public Map deserial map0 = mapReuse0; } else { map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 deserial map0 .put(key0, null); } else { if (unionIndex0 == 1) { +<<<<<<< HEAD map0 .put(key0, deserializeTestRecord0(null, (decoder))); +======= + map0 .put(key0, deserializeTestRecord0(null, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'mapValue': "+ unionIndex0)); } @@ -71,12 +99,24 @@ public Map deserial chunkLen0 = (decoder.mapNext()); } while (chunkLen0 > 0); } else { +<<<<<<< HEAD map0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } return map0; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; @@ -86,6 +126,7 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); } TestRecord.put(0, (decoder.readInt())); +<<<<<<< HEAD populate_TestRecord0((TestRecord), (decoder)); populate_TestRecord1((TestRecord), (decoder)); populate_TestRecord2((TestRecord), (decoder)); @@ -109,6 +150,31 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco } private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex1 = (decoder.readIndex()); @@ -125,7 +191,11 @@ private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(2, (decoder.readLong())); } +<<<<<<< HEAD private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex2 = (decoder.readIndex()); @@ -142,7 +212,11 @@ private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(4, (decoder.readDouble())); } +<<<<<<< HEAD private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); @@ -159,7 +233,11 @@ private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(6, (decoder.readFloat())); } +<<<<<<< HEAD private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex4 = (decoder.readIndex()); @@ -176,7 +254,11 @@ private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(8, (decoder.readBoolean())); } +<<<<<<< HEAD private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex5 = (decoder.readIndex()); @@ -200,7 +282,11 @@ private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(10, byteBuffer0); } +<<<<<<< HEAD private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex6 = (decoder.readIndex()); @@ -231,7 +317,11 @@ private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(12, charSequence0); } +<<<<<<< HEAD private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex7 = (decoder.readIndex()); @@ -265,7 +355,11 @@ private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(14, testFixed1); } +<<<<<<< HEAD private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex8 = (decoder.readIndex()); @@ -325,7 +419,11 @@ private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(16, testFixedArray0); } +<<<<<<< HEAD private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testFixedUnionArray0 = null; @@ -375,7 +473,11 @@ private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(18, Enums.getConstant(TestEnum.class, (decoder.readEnum()))); } +<<<<<<< HEAD private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex10 = (decoder.readIndex()); @@ -411,7 +513,11 @@ private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(20, testEnumArray0); } +<<<<<<< HEAD private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testEnumUnionArray0 = null; @@ -454,14 +560,22 @@ private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(22, null); } else { if (unionIndex12 == 1) { +<<<<<<< HEAD TestRecord.put(22, deserializeSubRecord0(TestRecord.get(22), (decoder))); +======= + TestRecord.put(22, deserializeSubRecord0(TestRecord.get(22), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'subRecordUnion': "+ unionIndex12)); } } } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord; @@ -488,11 +602,19 @@ public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex13)); } } +<<<<<<< HEAD populate_SubRecord0((SubRecord), (decoder)); return SubRecord; } private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord, Decoder decoder) +======= + populate_SubRecord0((SubRecord), (customization), (decoder)); + return SubRecord; + } + + private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex14 = (decoder.readIndex()); @@ -515,10 +637,17 @@ private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubR } } +<<<<<<< HEAD private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) throws IOException { TestRecord.put(23, deserializeSubRecord0(TestRecord.get(23), (decoder))); +======= + private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + TestRecord.put(23, deserializeSubRecord0(TestRecord.get(23), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) List recordsArray0 = null; long chunkLen5 = (decoder.readArrayStart()); Object oldArray4 = TestRecord.get(24); @@ -538,19 +667,28 @@ private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.Te if (oldArray4 instanceof GenericArray) { recordsArrayArrayElementReuseVar0 = ((GenericArray) oldArray4).peek(); } +<<<<<<< HEAD recordsArray0 .add(deserializeSubRecord0(recordsArrayArrayElementReuseVar0, (decoder))); +======= + recordsArray0 .add(deserializeSubRecord0(recordsArrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen5 = (decoder.arrayNext()); } TestRecord.put(24, recordsArray0); } +<<<<<<< HEAD private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map recordsMap0 = null; long chunkLen6 = (decoder.readMapStart()); if (chunkLen6 > 0) { +<<<<<<< HEAD Map recordsMapReuse0 = null; Object oldMap0 = TestRecord.get(25); if (oldMap0 instanceof Map) { @@ -561,16 +699,44 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te recordsMap0 = recordsMapReuse0; } else { recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter6 = 0; (counter6 >>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen6 = (decoder.mapNext()); } while (chunkLen6 > 0); } else { +<<<<<<< HEAD recordsMap0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(25, recordsMap0); int unionIndex15 = (decoder.readIndex()); @@ -604,7 +770,11 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayUnionOption0 .add(null); } else { if (unionIndex16 == 1) { +<<<<<<< HEAD recordsArrayUnionOption0 .add(deserializeSubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder))); +======= + recordsArrayUnionOption0 .add(deserializeSubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayUnionOptionElem': "+ unionIndex16)); } @@ -619,7 +789,11 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex17 = (decoder.readIndex()); @@ -631,6 +805,7 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te Map recordsMapUnionOption0 = null; long chunkLen8 = (decoder.readMapStart()); if (chunkLen8 > 0) { +<<<<<<< HEAD Map recordsMapUnionOptionReuse0 = null; Object oldMap1 = TestRecord.get(27); if (oldMap1 instanceof Map) { @@ -641,6 +816,22 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te recordsMapUnionOption0 = recordsMapUnionOptionReuse0; } else { recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter8 = 0; (counter8 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapUnionOptionValue': "+ unionIndex18)); } @@ -660,7 +855,15 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te chunkLen8 = (decoder.mapNext()); } while (chunkLen8 > 0); } else { +<<<<<<< HEAD recordsMapUnionOption0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(27, recordsMapUnionOption0); } else { @@ -689,6 +892,7 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te Map recordsArrayMapElem0 = null; long chunkLen10 = (decoder.readMapStart()); if (chunkLen10 > 0) { +<<<<<<< HEAD Map recordsArrayMapElemReuse0 = null; if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); @@ -698,6 +902,21 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayMapElem0 = recordsArrayMapElemReuse0; } else { recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter10 = 0; (counter10 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapElemValue': "+ unionIndex19)); } @@ -717,7 +940,15 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te chunkLen10 = (decoder.mapNext()); } while (chunkLen10 > 0); } else { +<<<<<<< HEAD recordsArrayMapElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMap0 .add(recordsArrayMapElem0); } @@ -726,12 +957,17 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(28, recordsArrayMap0); } +<<<<<<< HEAD private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map> recordsMapArray0 = null; long chunkLen11 = (decoder.readMapStart()); if (chunkLen11 > 0) { +<<<<<<< HEAD Map> recordsMapArrayReuse0 = null; Object oldMap2 = TestRecord.get(29); if (oldMap2 instanceof Map) { @@ -742,6 +978,22 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te recordsMapArray0 = recordsMapArrayReuse0; } else { recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter11 = 0; (counter11 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayValueElem': "+ unionIndex20)); } @@ -783,7 +1039,15 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te chunkLen11 = (decoder.mapNext()); } while (chunkLen11 > 0); } else { +<<<<<<< HEAD recordsMapArray0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(29, recordsMapArray0); int unionIndex21 = (decoder.readIndex()); @@ -814,6 +1078,7 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te Map recordsArrayMapUnionOptionElem0 = null; long chunkLen14 = (decoder.readMapStart()); if (chunkLen14 > 0) { +<<<<<<< HEAD Map recordsArrayMapUnionOptionElemReuse0 = null; if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); @@ -823,6 +1088,21 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; } else { recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter14 = 0; (counter14 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnionOptionElemValue': "+ unionIndex22)); } @@ -842,7 +1126,15 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te chunkLen14 = (decoder.mapNext()); } while (chunkLen14 > 0); } else { +<<<<<<< HEAD recordsArrayMapUnionOptionElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); } @@ -855,7 +1147,11 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex23 = (decoder.readIndex()); @@ -867,6 +1163,7 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te Map> recordsMapArrayUnionOption0 = null; long chunkLen15 = (decoder.readMapStart()); if (chunkLen15 > 0) { +<<<<<<< HEAD Map> recordsMapArrayUnionOptionReuse0 = null; Object oldMap3 = TestRecord.get(31); if (oldMap3 instanceof Map) { @@ -877,6 +1174,22 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; } else { recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter15 = 0; (counter15 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnionOptionValueElem': "+ unionIndex24)); } @@ -918,7 +1235,15 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te chunkLen15 = (decoder.mapNext()); } while (chunkLen15 > 0); } else { +<<<<<<< HEAD recordsMapArrayUnionOption0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(31, recordsMapArrayUnionOption0); } else { @@ -931,7 +1256,11 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(32, null); } else { if (unionIndex25 == 1) { +<<<<<<< HEAD TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder))); +======= + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { if (unionIndex25 == 2) { Utf8 charSequence4; @@ -953,7 +1282,11 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveBooleanList booleanArray0 = null; @@ -990,7 +1323,11 @@ private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(34, doubleArray0); } +<<<<<<< HEAD private void populate_TestRecord17(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord17(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveFloatList floatArray0 = null; @@ -1014,7 +1351,11 @@ private void populate_TestRecord17(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(36, intArray0); } +<<<<<<< HEAD private void populate_TestRecord18(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord18(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveLongList longArray0 = null; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_record_GenericDeserializer_1223705675_568621313.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_record_GenericDeserializer_1223705675_568621313.java index 24f5dc5ce..8d4d4825a 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_record_GenericDeserializer_1223705675_568621313.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_record_GenericDeserializer_1223705675_568621313.java @@ -5,6 +5,10 @@ import java.util.HashMap; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.AvroTypeException; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -23,7 +27,11 @@ public Map_of_record_GenericDeserializer_1223705675_568621313(Schema readerSchem this.unionOptionMapValueSchema0 = readerSchema.getValueType(); } +<<<<<<< HEAD public Map deserialize(Map reuse, Decoder decoder) +======= + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -34,6 +42,7 @@ public Map deserialize(Map reuse, Deco Map unionOption0 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map unionOptionReuse0 = null; if ((reuse) instanceof Map) { unionOptionReuse0 = ((Map)(reuse)); @@ -43,16 +52,43 @@ public Map deserialize(Map reuse, Deco unionOption0 = unionOptionReuse0; } else { unionOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map unionOptionReuse0 = null; + if ((reuse) instanceof Map) { + unionOptionReuse0 = ((Map)(reuse)); + } + if (unionOptionReuse0 != (null)) { + unionOptionReuse0 .clear(); + unionOption0 = unionOptionReuse0; + } else { + unionOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 >>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen0 = (decoder.mapNext()); } while (chunkLen0 > 0); } else { +<<<<<<< HEAD unionOption0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + unionOption0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } return unionOption0; } else { @@ -61,7 +97,11 @@ public Map deserialize(Map reuse, Deco } } +<<<<<<< HEAD public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_record_GenericDeserializer_1677529043_1677529043.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_record_GenericDeserializer_1677529043_1677529043.java index 6185ef7aa..445e9ad8a 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_record_GenericDeserializer_1677529043_1677529043.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/Map_of_record_GenericDeserializer_1677529043_1677529043.java @@ -5,6 +5,10 @@ import java.util.HashMap; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -24,12 +28,17 @@ public Map_of_record_GenericDeserializer_1677529043_1677529043(Schema readerSche this.field0 = mapMapValueSchema0 .getField("field").schema(); } +<<<<<<< HEAD public Map deserialize(Map reuse, Decoder decoder) +======= + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map map0 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map mapReuse0 = null; if ((reuse) instanceof Map) { mapReuse0 = ((Map)(reuse)); @@ -39,21 +48,52 @@ public Map deserialize(Map reuse, Deco map0 = mapReuse0; } else { map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 >>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen0 = (decoder.mapNext()); } while (chunkLen0 > 0); } else { +<<<<<<< HEAD map0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } return map0; } +<<<<<<< HEAD public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java index 25706d7ee..88be4cb8b 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.AvroTypeException; import org.apache.avro.Schema; import org.apache.avro.io.Decoder; @@ -18,6 +22,7 @@ public RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609(Sche this.readerSchema = readerSchema; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserialize(com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField reuse, Decoder decoder) throws IOException { @@ -25,6 +30,15 @@ public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField dese } public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserializeRecordWithLargeUnionField0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserialize(com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRecordWithLargeUnionField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserializeRecordWithLargeUnionField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField RecordWithLargeUnionField; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java index effdb2b31..9246e05b8 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.io.Decoder; import org.apache.avro.util.Utf8; @@ -17,6 +21,7 @@ public RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691(Schema re this.readerSchema = readerSchema; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder) throws IOException { @@ -24,6 +29,15 @@ public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deseria } public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java index dcbd0544d..613da9dc5 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.io.Decoder; @@ -18,6 +22,7 @@ public RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691(Schema rea this.readerSchema = readerSchema; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder) throws IOException { @@ -25,6 +30,15 @@ public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deseria } public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; @@ -41,6 +55,7 @@ public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deseria charSequence0 = (decoder).readString(null); } RemovedTypesTestRecord.put(0, charSequence0); +<<<<<<< HEAD populate_RemovedTypesTestRecord0((RemovedTypesTestRecord), (decoder)); populate_RemovedTypesTestRecord1((RemovedTypesTestRecord), (decoder)); populate_RemovedTypesTestRecord2((RemovedTypesTestRecord), (decoder)); @@ -57,6 +72,24 @@ public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deseria } private void populate_RemovedTypesTestRecord0(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, Decoder decoder) +======= + populate_RemovedTypesTestRecord0((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord1((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord2((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord3((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord4((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord5((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord6((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord7((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord8((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord9((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord10((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord11((RemovedTypesTestRecord), (customization), (decoder)); + return RemovedTypesTestRecord; + } + + private void populate_RemovedTypesTestRecord0(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { decoder.skipBytes(); @@ -73,7 +106,11 @@ private void populate_RemovedTypesTestRecord0(com.linkedin.avro.fastserde.genera } } +<<<<<<< HEAD private void populate_RemovedTypesTestRecord1(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, Decoder decoder) +======= + private void populate_RemovedTypesTestRecord1(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -98,7 +135,11 @@ private void populate_RemovedTypesTestRecord1(com.linkedin.avro.fastserde.genera } } +<<<<<<< HEAD private void populate_RemovedTypesTestRecord2(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, Decoder decoder) +======= + private void populate_RemovedTypesTestRecord2(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { long chunkLen2 = (decoder.readArrayStart()); @@ -142,7 +183,11 @@ private void populate_RemovedTypesTestRecord2(com.linkedin.avro.fastserde.genera } } +<<<<<<< HEAD private void populate_RemovedTypesTestRecord3(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, Decoder decoder) +======= + private void populate_RemovedTypesTestRecord3(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { decoder.skipFixed(1); @@ -158,7 +203,11 @@ private void populate_RemovedTypesTestRecord3(com.linkedin.avro.fastserde.genera } } +<<<<<<< HEAD private void populate_RemovedTypesTestRecord4(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, Decoder decoder) +======= + private void populate_RemovedTypesTestRecord4(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { long chunkLen4 = (decoder.readArrayStart()); @@ -184,7 +233,11 @@ private void populate_RemovedTypesTestRecord4(com.linkedin.avro.fastserde.genera } } +<<<<<<< HEAD private void populate_RemovedTypesTestRecord5(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, Decoder decoder) +======= + private void populate_RemovedTypesTestRecord5(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { long chunkLen6 = (decoder.readArrayStart()); @@ -228,7 +281,11 @@ private void populate_RemovedTypesTestRecord5(com.linkedin.avro.fastserde.genera } } +<<<<<<< HEAD private void populate_RemovedTypesTestRecord6(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, Decoder decoder) +======= + private void populate_RemovedTypesTestRecord6(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { decoder.readEnum(); @@ -244,7 +301,11 @@ private void populate_RemovedTypesTestRecord6(com.linkedin.avro.fastserde.genera } } +<<<<<<< HEAD private void populate_RemovedTypesTestRecord7(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, Decoder decoder) +======= + private void populate_RemovedTypesTestRecord7(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { long chunkLen8 = (decoder.readArrayStart()); @@ -266,7 +327,11 @@ private void populate_RemovedTypesTestRecord7(com.linkedin.avro.fastserde.genera } } +<<<<<<< HEAD private void populate_RemovedTypesTestRecord8(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, Decoder decoder) +======= + private void populate_RemovedTypesTestRecord8(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { long chunkLen10 = (decoder.readArrayStart()); @@ -310,29 +375,48 @@ private void populate_RemovedTypesTestRecord8(com.linkedin.avro.fastserde.genera } } +<<<<<<< HEAD private void populate_RemovedTypesTestRecord9(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, Decoder decoder) throws IOException { deserializeRemovedSubRecord0(null, (decoder)); +======= + private void populate_RemovedTypesTestRecord9(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializeRemovedSubRecord0(null, (decoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) int unionIndex9 = (decoder.readIndex()); if (unionIndex9 == 0) { decoder.readNull(); } else { if (unionIndex9 == 1) { +<<<<<<< HEAD deserializeRemovedSubRecord0(null, (decoder)); +======= + deserializeRemovedSubRecord0(null, (decoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'removedSubRecordUnion': "+ unionIndex9)); } } } +<<<<<<< HEAD public void deserializeRemovedSubRecord0(Object reuse, Decoder decoder) +======= + public void deserializeRemovedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { decoder.skipString(); } +<<<<<<< HEAD private void populate_RemovedTypesTestRecord10(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, Decoder decoder) +======= + private void populate_RemovedTypesTestRecord10(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { long chunkLen12 = (decoder.readArrayStart()); @@ -342,7 +426,11 @@ private void populate_RemovedTypesTestRecord10(com.linkedin.avro.fastserde.gener if (null instanceof GenericArray) { removedSubRecordArrayArrayElementReuseVar0 = ((GenericArray) null).peek(); } +<<<<<<< HEAD deserializeRemovedSubRecord0(removedSubRecordArrayArrayElementReuseVar0, (decoder)); +======= + deserializeRemovedSubRecord0(removedSubRecordArrayArrayElementReuseVar0, (decoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen12 = (decoder.arrayNext()); } @@ -358,7 +446,11 @@ private void populate_RemovedTypesTestRecord10(com.linkedin.avro.fastserde.gener decoder.readNull(); } else { if (unionIndex10 == 1) { +<<<<<<< HEAD deserializeRemovedSubRecord0(removedSubRecordUnionArrayArrayElementReuseVar0, (decoder)); +======= + deserializeRemovedSubRecord0(removedSubRecordUnionArrayArrayElementReuseVar0, (decoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'removedSubRecordUnionArrayElem': "+ unionIndex10)); } @@ -368,7 +460,11 @@ private void populate_RemovedTypesTestRecord10(com.linkedin.avro.fastserde.gener } } +<<<<<<< HEAD private void populate_RemovedTypesTestRecord11(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, Decoder decoder) +======= + private void populate_RemovedTypesTestRecord11(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { long chunkLen14 = (decoder.readMapStart()); @@ -376,7 +472,11 @@ private void populate_RemovedTypesTestRecord11(com.linkedin.avro.fastserde.gener do { for (int counter14 = 0; (counter14 >>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen14 = (decoder.mapNext()); } while (chunkLen14 > 0); @@ -391,7 +491,11 @@ private void populate_RemovedTypesTestRecord11(com.linkedin.avro.fastserde.gener decoder.readNull(); } else { if (unionIndex11 == 1) { +<<<<<<< HEAD deserializeRemovedSubRecord0(null, (decoder)); +======= + deserializeRemovedSubRecord0(null, (decoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'removedSubRecordUnionMapValue': "+ unionIndex11)); } diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java index bc6c0ce3f..7a39f813e 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java @@ -5,6 +5,10 @@ import java.util.ArrayList; import java.util.List; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.io.Decoder; @@ -20,6 +24,7 @@ public SplitRecordTest1_SpecificDeserializer_1718878379_595582209(Schema readerS this.readerSchema = readerSchema; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 reuse, Decoder decoder) throws IOException { @@ -27,6 +32,15 @@ public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserialize(c } public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserializeSplitRecordTest10(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeSplitRecordTest10((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserializeSplitRecordTest10(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 SplitRecordTest1; @@ -35,12 +49,21 @@ public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserializeSp } else { SplitRecordTest1 = new com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1(); } +<<<<<<< HEAD SplitRecordTest1 .put(0, deserializeFullRecord0(SplitRecordTest1 .get(0), (decoder))); populate_SplitRecordTest10((SplitRecordTest1), (decoder)); return SplitRecordTest1; } public com.linkedin.avro.fastserde.generated.avro.FullRecord deserializeFullRecord0(Object reuse, Decoder decoder) +======= + SplitRecordTest1 .put(0, deserializeFullRecord0(SplitRecordTest1 .get(0), (decoder), (customization))); + populate_SplitRecordTest10((SplitRecordTest1), (customization), (decoder)); + return SplitRecordTest1; + } + + public com.linkedin.avro.fastserde.generated.avro.FullRecord deserializeFullRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.FullRecord FullRecord; @@ -71,10 +94,17 @@ public com.linkedin.avro.fastserde.generated.avro.FullRecord deserializeFullReco return FullRecord; } +<<<<<<< HEAD private void populate_SplitRecordTest10(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 SplitRecordTest1, Decoder decoder) throws IOException { SplitRecordTest1 .put(1, deserializeFullRecord1(SplitRecordTest1 .get(1), (decoder))); +======= + private void populate_SplitRecordTest10(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 SplitRecordTest1, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + SplitRecordTest1 .put(1, deserializeFullRecord1(SplitRecordTest1 .get(1), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) List record30 = null; long chunkLen0 = (decoder.readArrayStart()); Object oldArray0 = SplitRecordTest1 .get(2); @@ -94,14 +124,22 @@ private void populate_SplitRecordTest10(com.linkedin.avro.fastserde.generated.av if (oldArray0 instanceof GenericArray) { record3ArrayElementReuseVar0 = ((GenericArray) oldArray0).peek(); } +<<<<<<< HEAD record30 .add(deserializeFullRecord2(record3ArrayElementReuseVar0, (decoder))); +======= + record30 .add(deserializeFullRecord2(record3ArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen0 = (decoder.arrayNext()); } SplitRecordTest1 .put(2, record30); } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.FullRecord deserializeFullRecord1(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.FullRecord deserializeFullRecord1(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.FullRecord FullRecord; @@ -125,7 +163,11 @@ public com.linkedin.avro.fastserde.generated.avro.FullRecord deserializeFullReco return FullRecord; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.FullRecord deserializeFullRecord2(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.FullRecord deserializeFullRecord2(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.FullRecord FullRecord; @@ -152,11 +194,19 @@ public com.linkedin.avro.fastserde.generated.avro.FullRecord deserializeFullReco throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex2)); } } +<<<<<<< HEAD populate_FullRecord0((FullRecord), (decoder)); return FullRecord; } private void populate_FullRecord0(com.linkedin.avro.fastserde.generated.avro.FullRecord FullRecord, Decoder decoder) +======= + populate_FullRecord0((FullRecord), (customization), (decoder)); + return FullRecord; + } + + private void populate_FullRecord0(com.linkedin.avro.fastserde.generated.avro.FullRecord FullRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/SplitRecordTest2_SpecificDeserializer_595582209_1718878379.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/SplitRecordTest2_SpecificDeserializer_595582209_1718878379.java index c9d12c196..5ebbdaf5b 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/SplitRecordTest2_SpecificDeserializer_595582209_1718878379.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/SplitRecordTest2_SpecificDeserializer_595582209_1718878379.java @@ -5,6 +5,10 @@ import java.util.ArrayList; import java.util.List; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.generated.avro.FullRecord; import com.linkedin.avro.fastserde.generated.avro.StringRecord; import org.apache.avro.Schema; @@ -22,6 +26,7 @@ public SplitRecordTest2_SpecificDeserializer_595582209_1718878379(Schema readerS this.readerSchema = readerSchema; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 reuse, Decoder decoder) throws IOException { @@ -29,6 +34,15 @@ public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserialize(c } public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserializeSplitRecordTest20(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeSplitRecordTest20((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserializeSplitRecordTest20(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 SplitRecordTest2; @@ -37,12 +51,21 @@ public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserializeSp } else { SplitRecordTest2 = new com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2(); } +<<<<<<< HEAD SplitRecordTest2 .put(0, deserializeStringRecord0(SplitRecordTest2 .get(0), (decoder))); populate_SplitRecordTest20((SplitRecordTest2), (decoder)); return SplitRecordTest2; } public StringRecord deserializeStringRecord0(Object reuse, Decoder decoder) +======= + SplitRecordTest2 .put(0, deserializeStringRecord0(SplitRecordTest2 .get(0), (decoder), (customization))); + populate_SplitRecordTest20((SplitRecordTest2), (customization), (decoder)); + return SplitRecordTest2; + } + + public StringRecord deserializeStringRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { StringRecord IntRecord; @@ -69,11 +92,19 @@ public StringRecord deserializeStringRecord0(Object reuse, Decoder decoder) throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex0)); } } +<<<<<<< HEAD populate_IntRecord0((IntRecord), (decoder)); return IntRecord; } private void populate_IntRecord0(StringRecord IntRecord, Decoder decoder) +======= + populate_IntRecord0((IntRecord), (customization), (decoder)); + return IntRecord; + } + + private void populate_IntRecord0(StringRecord IntRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex1 = (decoder.readIndex()); @@ -88,10 +119,17 @@ private void populate_IntRecord0(StringRecord IntRecord, Decoder decoder) } } +<<<<<<< HEAD private void populate_SplitRecordTest20(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 SplitRecordTest2, Decoder decoder) throws IOException { SplitRecordTest2 .put(1, deserializeIntRecord0(SplitRecordTest2 .get(1), (decoder))); +======= + private void populate_SplitRecordTest20(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 SplitRecordTest2, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + SplitRecordTest2 .put(1, deserializeIntRecord0(SplitRecordTest2 .get(1), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) List record30 = null; long chunkLen0 = (decoder.readArrayStart()); Object oldArray0 = SplitRecordTest2 .get(2); @@ -111,14 +149,22 @@ private void populate_SplitRecordTest20(com.linkedin.avro.fastserde.generated.av if (oldArray0 instanceof GenericArray) { record3ArrayElementReuseVar0 = ((GenericArray) oldArray0).peek(); } +<<<<<<< HEAD record30 .add(deserializeFullRecord0(record3ArrayElementReuseVar0, (decoder))); +======= + record30 .add(deserializeFullRecord0(record3ArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen0 = (decoder.arrayNext()); } SplitRecordTest2 .put(2, record30); } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.IntRecord deserializeIntRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.IntRecord deserializeIntRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.IntRecord IntRecord; @@ -137,11 +183,19 @@ public com.linkedin.avro.fastserde.generated.avro.IntRecord deserializeIntRecord throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex2)); } } +<<<<<<< HEAD populate_IntRecord1((IntRecord), (decoder)); return IntRecord; } private void populate_IntRecord1(com.linkedin.avro.fastserde.generated.avro.IntRecord IntRecord, Decoder decoder) +======= + populate_IntRecord1((IntRecord), (customization), (decoder)); + return IntRecord; + } + + private void populate_IntRecord1(com.linkedin.avro.fastserde.generated.avro.IntRecord IntRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); @@ -157,7 +211,11 @@ private void populate_IntRecord1(com.linkedin.avro.fastserde.generated.avro.IntR } } +<<<<<<< HEAD public FullRecord deserializeFullRecord0(Object reuse, Decoder decoder) +======= + public FullRecord deserializeFullRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { FullRecord IntRecord; @@ -184,11 +242,19 @@ public FullRecord deserializeFullRecord0(Object reuse, Decoder decoder) throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex4)); } } +<<<<<<< HEAD populate_IntRecord2((IntRecord), (decoder)); return IntRecord; } private void populate_IntRecord2(FullRecord IntRecord, Decoder decoder) +======= + populate_IntRecord2((IntRecord), (customization), (decoder)); + return IntRecord; + } + + private void populate_IntRecord2(FullRecord IntRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex5 = (decoder.readIndex()); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/StringableRecord_SpecificDeserializer_842267318_842267318.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/StringableRecord_SpecificDeserializer_842267318_842267318.java index e9ab6defe..baa117c2b 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/StringableRecord_SpecificDeserializer_842267318_842267318.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/StringableRecord_SpecificDeserializer_842267318_842267318.java @@ -14,6 +14,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.AvroRuntimeException; import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; @@ -30,11 +34,19 @@ public StringableRecord_SpecificDeserializer_842267318_842267318(Schema readerSc this.readerSchema = readerSchema; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserialize(com.linkedin.avro.fastserde.generated.avro.StringableRecord reuse, Decoder decoder) throws IOException { try { return deserializeStringableRecord0((reuse), (decoder)); +======= + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserialize(com.linkedin.avro.fastserde.generated.avro.StringableRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + try { + return deserializeStringableRecord0((reuse), (decoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } catch (NumberFormatException e) { throw new AvroRuntimeException(e); } catch (MalformedURLException e) { @@ -44,7 +56,11 @@ public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserialize(c } } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserializeStringableRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserializeStringableRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException, NumberFormatException, MalformedURLException, URISyntaxException { com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord; @@ -55,6 +71,7 @@ public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserializeSt } BigInteger charSequence0 = new BigInteger((decoder.readString())); StringableRecord.put(0, charSequence0); +<<<<<<< HEAD populate_StringableRecord0((StringableRecord), (decoder)); populate_StringableRecord1((StringableRecord), (decoder)); populate_StringableRecord2((StringableRecord), (decoder)); @@ -64,6 +81,17 @@ public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserializeSt } private void populate_StringableRecord0(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, Decoder decoder) +======= + populate_StringableRecord0((StringableRecord), (customization), (decoder)); + populate_StringableRecord1((StringableRecord), (customization), (decoder)); + populate_StringableRecord2((StringableRecord), (customization), (decoder)); + populate_StringableRecord3((StringableRecord), (customization), (decoder)); + populate_StringableRecord4((StringableRecord), (customization), (decoder)); + return StringableRecord; + } + + private void populate_StringableRecord0(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException, NumberFormatException, URISyntaxException { BigDecimal charSequence1 = new BigDecimal((decoder.readString())); @@ -72,7 +100,11 @@ private void populate_StringableRecord0(com.linkedin.avro.fastserde.generated.av StringableRecord.put(2, charSequence2); } +<<<<<<< HEAD private void populate_StringableRecord1(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, Decoder decoder) +======= + private void populate_StringableRecord1(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException, NumberFormatException, MalformedURLException, URISyntaxException { URL charSequence3 = new URL((decoder.readString())); @@ -81,7 +113,11 @@ private void populate_StringableRecord1(com.linkedin.avro.fastserde.generated.av StringableRecord.put(4, charSequence4); } +<<<<<<< HEAD private void populate_StringableRecord2(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, Decoder decoder) +======= + private void populate_StringableRecord2(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException, NumberFormatException, MalformedURLException, URISyntaxException { List urlArray0 = null; @@ -112,6 +148,7 @@ private void populate_StringableRecord2(com.linkedin.avro.fastserde.generated.av Map urlMap0 = null; long chunkLen1 = (decoder.readMapStart()); if (chunkLen1 > 0) { +<<<<<<< HEAD Map urlMapReuse0 = null; Object oldMap0 = StringableRecord.get(6); if (oldMap0 instanceof Map) { @@ -122,6 +159,22 @@ private void populate_StringableRecord2(com.linkedin.avro.fastserde.generated.av urlMap0 = urlMapReuse0; } else { urlMap0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), ((int) chunkLen1))); + } else { + Map urlMapReuse0 = null; + Object oldMap0 = StringableRecord.get(6); + if (oldMap0 instanceof Map) { + urlMapReuse0 = ((Map) oldMap0); + } + if (urlMapReuse0 != (null)) { + urlMapReuse0 .clear(); + urlMap0 = urlMapReuse0; + } else { + urlMap0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter1 = 0; (counter1 0); } else { +<<<<<<< HEAD urlMap0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), 0)); + } else { + urlMap0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } StringableRecord.put(6, urlMap0); } +<<<<<<< HEAD private void populate_StringableRecord3(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, Decoder decoder) throws IOException, NumberFormatException, MalformedURLException, URISyntaxException { @@ -145,6 +207,16 @@ private void populate_StringableRecord3(com.linkedin.avro.fastserde.generated.av } public com.linkedin.avro.fastserde.generated.avro.StringableSubRecord deserializeStringableSubRecord0(Object reuse, Decoder decoder) +======= + private void populate_StringableRecord3(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + StringableRecord.put(7, deserializeStringableSubRecord0(StringableRecord.get(7), (decoder), (customization))); + StringableRecord.put(8, deserializeAnotherSubRecord0(StringableRecord.get(8), (decoder), (customization))); + } + + public com.linkedin.avro.fastserde.generated.avro.StringableSubRecord deserializeStringableSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException, URISyntaxException { com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord; @@ -155,11 +227,19 @@ public com.linkedin.avro.fastserde.generated.avro.StringableSubRecord deserializ } URI charSequence7 = new URI((decoder.readString())); StringableSubRecord.put(0, charSequence7); +<<<<<<< HEAD populate_StringableSubRecord0((StringableSubRecord), (decoder)); return StringableSubRecord; } private void populate_StringableSubRecord0(com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord, Decoder decoder) +======= + populate_StringableSubRecord0((StringableSubRecord), (customization), (decoder)); + return StringableSubRecord; + } + + private void populate_StringableSubRecord0(com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException, URISyntaxException { int unionIndex0 = (decoder.readIndex()); @@ -186,7 +266,11 @@ private void populate_StringableSubRecord0(com.linkedin.avro.fastserde.generated } } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord deserializeAnotherSubRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord deserializeAnotherSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException, URISyntaxException { com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord AnotherSubRecord; @@ -195,11 +279,19 @@ public com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord deserializeAn } else { AnotherSubRecord = new com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord(); } +<<<<<<< HEAD AnotherSubRecord.put(0, deserializeStringableSubRecord0(AnotherSubRecord.get(0), (decoder))); return AnotherSubRecord; } private void populate_StringableRecord4(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, Decoder decoder) +======= + AnotherSubRecord.put(0, deserializeStringableSubRecord0(AnotherSubRecord.get(0), (decoder), (customization))); + return AnotherSubRecord; + } + + private void populate_StringableRecord4(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException, NumberFormatException, MalformedURLException, URISyntaxException { int unionIndex1 = (decoder.readIndex()); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java index 6aa9a2730..6367ff26c 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java @@ -5,6 +5,10 @@ import com.linkedin.avro.api.PrimitiveFloatList; import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -21,6 +25,7 @@ public TestArrayOfFloats_GenericDeserializer_1408566797_1408566797(Schema reader this.array_of_float0 = readerSchema.getField("array_of_float").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -28,6 +33,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeTestArrayOfFloats0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestArrayOfFloats0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestArrayOfFloats0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord TestArrayOfFloats; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_GenericDeserializer_473555078_473555078.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_GenericDeserializer_473555078_473555078.java index 0200ae69f..9e2170563 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_GenericDeserializer_473555078_473555078.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_GenericDeserializer_473555078_473555078.java @@ -5,6 +5,10 @@ import java.util.HashMap; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -22,6 +26,7 @@ public TestRecord_GenericDeserializer_473555078_473555078(Schema readerSchema) { this.map_field0 = readerSchema.getField("map_field").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -29,6 +34,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializeTestRecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord TestRecord; @@ -40,6 +54,7 @@ public IndexedRecord deserializeTestRecord0(Object reuse, Decoder decoder) Map map_field1 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map map_fieldReuse0 = null; Object oldMap0 = TestRecord.get(0); if (oldMap0 instanceof Map) { @@ -50,6 +65,22 @@ public IndexedRecord deserializeTestRecord0(Object reuse, Decoder decoder) map_field1 = map_fieldReuse0; } else { map_field1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), ((int) chunkLen0))); + } else { + Map map_fieldReuse0 = null; + Object oldMap0 = TestRecord.get(0); + if (oldMap0 instanceof Map) { + map_fieldReuse0 = ((Map) oldMap0); + } + if (map_fieldReuse0 != (null)) { + map_fieldReuse0 .clear(); + map_field1 = map_fieldReuse0; + } else { + map_field1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 0); } else { +<<<<<<< HEAD map_field1 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), 0)); + } else { + map_field1 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(0, map_field1); return TestRecord; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_SpecificDeserializer_1898726132_553331077.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_SpecificDeserializer_1898726132_553331077.java index 80878a014..a5b35454b 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_SpecificDeserializer_1898726132_553331077.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_SpecificDeserializer_1898726132_553331077.java @@ -9,6 +9,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.generated.avro.TestEnum; import com.linkedin.avro.fastserde.generated.avro.TestFixed; import com.linkedin.avroutil1.Enums; @@ -61,6 +65,7 @@ public TestRecord_SpecificDeserializer_1898726132_553331077(Schema readerSchema) this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder) throws IOException { @@ -68,6 +73,15 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.lin } public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; @@ -77,6 +91,7 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); } TestRecord.put(0, (decoder.readInt())); +<<<<<<< HEAD populate_TestRecord0((TestRecord), (decoder)); populate_TestRecord1((TestRecord), (decoder)); populate_TestRecord2((TestRecord), (decoder)); @@ -94,6 +109,25 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco populate_TestRecord14((TestRecord), (decoder)); populate_TestRecord15((TestRecord), (decoder)); populate_TestRecord16((TestRecord), (decoder)); +======= + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) ArrayList defaultArray0 = new ArrayList(); TestRecord.put(33, defaultArray0); ArrayList defaultArray1 = new ArrayList(); @@ -109,7 +143,11 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco return TestRecord; } +<<<<<<< HEAD private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -126,7 +164,11 @@ private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(2, (decoder.readLong())); } +<<<<<<< HEAD private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex1 = (decoder.readIndex()); @@ -143,7 +185,11 @@ private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(4, (decoder.readDouble())); } +<<<<<<< HEAD private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex2 = (decoder.readIndex()); @@ -160,7 +206,11 @@ private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(6, (decoder.readFloat())); } +<<<<<<< HEAD private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); @@ -177,7 +227,11 @@ private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(8, (decoder.readBoolean())); } +<<<<<<< HEAD private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex4 = (decoder.readIndex()); @@ -201,7 +255,11 @@ private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(10, byteBuffer0); } +<<<<<<< HEAD private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex5 = (decoder.readIndex()); @@ -232,7 +290,11 @@ private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(12, charSequence0); } +<<<<<<< HEAD private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex6 = (decoder.readIndex()); @@ -265,7 +327,11 @@ private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.Tes } } +<<<<<<< HEAD private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { byte[] testFixed0; @@ -302,7 +368,11 @@ private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.Tes } } +<<<<<<< HEAD private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testFixedArray0 = null; @@ -385,7 +455,11 @@ private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(17, testFixedUnionArray0); } +<<<<<<< HEAD private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int enumIndex0 = (decoder.readEnum()); @@ -426,7 +500,11 @@ private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.Tes } } +<<<<<<< HEAD private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testEnumArray0 = null; @@ -509,7 +587,11 @@ private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(21, testEnumUnionArray0); } +<<<<<<< HEAD private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex12 = (decoder.readIndex()); @@ -518,15 +600,26 @@ private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(22, null); } else { if (unionIndex12 == 1) { +<<<<<<< HEAD TestRecord.put(22, deserializeSubRecord0(TestRecord.get(22), (decoder))); +======= + TestRecord.put(22, deserializeSubRecord0(TestRecord.get(22), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'subRecordUnion': "+ unionIndex12)); } } +<<<<<<< HEAD TestRecord.put(23, deserializeSubRecord0(TestRecord.get(23), (decoder))); } public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord0(Object reuse, Decoder decoder) +======= + TestRecord.put(23, deserializeSubRecord0(TestRecord.get(23), (decoder), (customization))); + } + + public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord; @@ -553,11 +646,19 @@ public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex13)); } } +<<<<<<< HEAD populate_SubRecord0((SubRecord), (decoder)); return SubRecord; } private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord, Decoder decoder) +======= + populate_SubRecord0((SubRecord), (customization), (decoder)); + return SubRecord; + } + + private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex14 = (decoder.readIndex()); @@ -590,7 +691,11 @@ private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubR } } +<<<<<<< HEAD private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List recordsArray0 = null; @@ -612,7 +717,11 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te if (oldArray4 instanceof GenericArray) { recordsArrayArrayElementReuseVar0 = ((GenericArray) oldArray4).peek(); } +<<<<<<< HEAD recordsArray0 .add(deserializeSubRecord0(recordsArrayArrayElementReuseVar0, (decoder))); +======= + recordsArray0 .add(deserializeSubRecord0(recordsArrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen4 = (decoder.arrayNext()); } @@ -620,6 +729,7 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te Map recordsMap0 = null; long chunkLen5 = (decoder.readMapStart()); if (chunkLen5 > 0) { +<<<<<<< HEAD Map recordsMapReuse0 = null; Object oldMap0 = TestRecord.get(25); if (oldMap0 instanceof Map) { @@ -630,21 +740,53 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te recordsMap0 = recordsMapReuse0; } else { recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter5 = 0; (counter5 >>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen5 = (decoder.mapNext()); } while (chunkLen5 > 0); } else { +<<<<<<< HEAD recordsMap0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(25, recordsMap0); } +<<<<<<< HEAD private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex16 = (decoder.readIndex()); @@ -678,7 +820,11 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayUnionOption0 .add(null); } else { if (unionIndex17 == 1) { +<<<<<<< HEAD recordsArrayUnionOption0 .add(deserializeSubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder))); +======= + recordsArrayUnionOption0 .add(deserializeSubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayUnionOptionElem': "+ unionIndex17)); } @@ -700,6 +846,7 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te Map recordsMapUnionOption0 = null; long chunkLen7 = (decoder.readMapStart()); if (chunkLen7 > 0) { +<<<<<<< HEAD Map recordsMapUnionOptionReuse0 = null; Object oldMap1 = TestRecord.get(27); if (oldMap1 instanceof Map) { @@ -710,6 +857,22 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te recordsMapUnionOption0 = recordsMapUnionOptionReuse0; } else { recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter7 = 0; (counter7 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapUnionOptionValue': "+ unionIndex19)); } @@ -729,7 +896,15 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te chunkLen7 = (decoder.mapNext()); } while (chunkLen7 > 0); } else { +<<<<<<< HEAD recordsMapUnionOption0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(27, recordsMapUnionOption0); } else { @@ -738,7 +913,11 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List> recordsArrayMap0 = null; @@ -763,6 +942,7 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te Map recordsArrayMapElem0 = null; long chunkLen9 = (decoder.readMapStart()); if (chunkLen9 > 0) { +<<<<<<< HEAD Map recordsArrayMapElemReuse0 = null; if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); @@ -772,6 +952,21 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayMapElem0 = recordsArrayMapElemReuse0; } else { recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter9 = 0; (counter9 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapElemValue': "+ unionIndex20)); } @@ -791,7 +990,15 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te chunkLen9 = (decoder.mapNext()); } while (chunkLen9 > 0); } else { +<<<<<<< HEAD recordsArrayMapElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMap0 .add(recordsArrayMapElem0); } @@ -801,6 +1008,7 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te Map> recordsMapArray0 = null; long chunkLen10 = (decoder.readMapStart()); if (chunkLen10 > 0) { +<<<<<<< HEAD Map> recordsMapArrayReuse0 = null; Object oldMap2 = TestRecord.get(29); if (oldMap2 instanceof Map) { @@ -811,6 +1019,22 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te recordsMapArray0 = recordsMapArrayReuse0; } else { recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter10 = 0; (counter10 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayValueElem': "+ unionIndex21)); } @@ -852,12 +1080,24 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te chunkLen10 = (decoder.mapNext()); } while (chunkLen10 > 0); } else { +<<<<<<< HEAD recordsMapArray0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(29, recordsMapArray0); } +<<<<<<< HEAD private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex22 = (decoder.readIndex()); @@ -888,6 +1128,7 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te Map recordsArrayMapUnionOptionElem0 = null; long chunkLen13 = (decoder.readMapStart()); if (chunkLen13 > 0) { +<<<<<<< HEAD Map recordsArrayMapUnionOptionElemReuse0 = null; if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); @@ -897,6 +1138,21 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; } else { recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter13 = 0; (counter13 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnionOptionElemValue': "+ unionIndex23)); } @@ -916,7 +1176,15 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te chunkLen13 = (decoder.mapNext()); } while (chunkLen13 > 0); } else { +<<<<<<< HEAD recordsArrayMapUnionOptionElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); } @@ -936,6 +1204,7 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te Map> recordsMapArrayUnionOption0 = null; long chunkLen14 = (decoder.readMapStart()); if (chunkLen14 > 0) { +<<<<<<< HEAD Map> recordsMapArrayUnionOptionReuse0 = null; Object oldMap3 = TestRecord.get(31); if (oldMap3 instanceof Map) { @@ -946,6 +1215,22 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; } else { recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter14 = 0; (counter14 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnionOptionValueElem': "+ unionIndex25)); } @@ -987,7 +1276,15 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te chunkLen14 = (decoder.mapNext()); } while (chunkLen14 > 0); } else { +<<<<<<< HEAD recordsMapArrayUnionOption0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(31, recordsMapArrayUnionOption0); } else { @@ -996,7 +1293,11 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex26 = (decoder.readIndex()); @@ -1005,7 +1306,11 @@ private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(32, null); } else { if (unionIndex26 == 1) { +<<<<<<< HEAD TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder))); +======= + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { if (unionIndex26 == 2) { Utf8 charSequence4; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_SpecificDeserializer_1991094399_553331077.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_SpecificDeserializer_1991094399_553331077.java index 4fb1c2f90..1d08f83bf 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_SpecificDeserializer_1991094399_553331077.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_SpecificDeserializer_1991094399_553331077.java @@ -9,6 +9,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.generated.avro.TestEnum; import com.linkedin.avro.fastserde.generated.avro.TestFixed; import com.linkedin.avroutil1.Enums; @@ -65,6 +69,7 @@ public TestRecord_SpecificDeserializer_1991094399_553331077(Schema readerSchema) this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder) throws IOException { @@ -72,6 +77,15 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.lin } public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; @@ -81,6 +95,7 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); } TestRecord.put(0, (decoder.readInt())); +<<<<<<< HEAD populate_TestRecord0((TestRecord), (decoder)); populate_TestRecord1((TestRecord), (decoder)); populate_TestRecord2((TestRecord), (decoder)); @@ -98,6 +113,25 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco populate_TestRecord14((TestRecord), (decoder)); populate_TestRecord15((TestRecord), (decoder)); populate_TestRecord16((TestRecord), (decoder)); +======= + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) ArrayList defaultArray0 = new ArrayList(); TestRecord.put(33, defaultArray0); ArrayList defaultArray1 = new ArrayList(); @@ -113,7 +147,11 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco return TestRecord; } +<<<<<<< HEAD private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -130,7 +168,11 @@ private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(2, (decoder.readLong())); } +<<<<<<< HEAD private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex1 = (decoder.readIndex()); @@ -147,7 +189,11 @@ private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(4, (decoder.readDouble())); } +<<<<<<< HEAD private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex2 = (decoder.readIndex()); @@ -164,7 +210,11 @@ private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(6, (decoder.readFloat())); } +<<<<<<< HEAD private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); @@ -181,7 +231,11 @@ private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(8, (decoder.readBoolean())); } +<<<<<<< HEAD private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex4 = (decoder.readIndex()); @@ -205,7 +259,11 @@ private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(10, byteBuffer0); } +<<<<<<< HEAD private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex5 = (decoder.readIndex()); @@ -236,7 +294,11 @@ private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(12, charSequence0); } +<<<<<<< HEAD private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex6 = (decoder.readIndex()); @@ -269,7 +331,11 @@ private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.Tes } } +<<<<<<< HEAD private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { byte[] testFixed0; @@ -306,7 +372,11 @@ private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.Tes } } +<<<<<<< HEAD private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testFixedArray0 = null; @@ -389,7 +459,11 @@ private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(17, testFixedUnionArray0); } +<<<<<<< HEAD private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int enumIndex0 = (decoder.readEnum()); @@ -430,7 +504,11 @@ private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.Tes } } +<<<<<<< HEAD private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testEnumArray0 = null; @@ -513,7 +591,11 @@ private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(21, testEnumUnionArray0); } +<<<<<<< HEAD private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex12 = (decoder.readIndex()); @@ -522,15 +604,26 @@ private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(22, null); } else { if (unionIndex12 == 1) { +<<<<<<< HEAD TestRecord.put(22, deserializeSubRecord0(TestRecord.get(22), (decoder))); +======= + TestRecord.put(22, deserializeSubRecord0(TestRecord.get(22), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'subRecordUnion': "+ unionIndex12)); } } +<<<<<<< HEAD TestRecord.put(23, deserializeSubRecord0(TestRecord.get(23), (decoder))); } public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord0(Object reuse, Decoder decoder) +======= + TestRecord.put(23, deserializeSubRecord0(TestRecord.get(23), (decoder), (customization))); + } + + public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord; @@ -557,11 +650,19 @@ public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex13)); } } +<<<<<<< HEAD populate_SubRecord0((SubRecord), (decoder)); return SubRecord; } private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord, Decoder decoder) +======= + populate_SubRecord0((SubRecord), (customization), (decoder)); + return SubRecord; + } + + private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex14 = (decoder.readIndex()); @@ -594,7 +695,11 @@ private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubR } } +<<<<<<< HEAD private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List recordsArray0 = null; @@ -616,7 +721,11 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te if (oldArray4 instanceof GenericArray) { recordsArrayArrayElementReuseVar0 = ((GenericArray) oldArray4).peek(); } +<<<<<<< HEAD recordsArray0 .add(deserializeSubRecord0(recordsArrayArrayElementReuseVar0, (decoder))); +======= + recordsArray0 .add(deserializeSubRecord0(recordsArrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen4 = (decoder.arrayNext()); } @@ -624,6 +733,7 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te Map recordsMap0 = null; long chunkLen5 = (decoder.readMapStart()); if (chunkLen5 > 0) { +<<<<<<< HEAD Map recordsMapReuse0 = null; Object oldMap0 = TestRecord.get(25); if (oldMap0 instanceof Map) { @@ -634,21 +744,53 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te recordsMap0 = recordsMapReuse0; } else { recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter5 = 0; (counter5 >>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen5 = (decoder.mapNext()); } while (chunkLen5 > 0); } else { +<<<<<<< HEAD recordsMap0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(25, recordsMap0); } +<<<<<<< HEAD private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex16 = (decoder.readIndex()); @@ -682,7 +824,11 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayUnionOption0 .add(null); } else { if (unionIndex17 == 1) { +<<<<<<< HEAD recordsArrayUnionOption0 .add(deserializeSubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder))); +======= + recordsArrayUnionOption0 .add(deserializeSubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayUnionOptionElem': "+ unionIndex17)); } @@ -704,6 +850,7 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te Map recordsMapUnionOption0 = null; long chunkLen7 = (decoder.readMapStart()); if (chunkLen7 > 0) { +<<<<<<< HEAD Map recordsMapUnionOptionReuse0 = null; Object oldMap1 = TestRecord.get(27); if (oldMap1 instanceof Map) { @@ -714,6 +861,22 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te recordsMapUnionOption0 = recordsMapUnionOptionReuse0; } else { recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter7 = 0; (counter7 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapUnionOptionValue': "+ unionIndex19)); } @@ -733,7 +900,15 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te chunkLen7 = (decoder.mapNext()); } while (chunkLen7 > 0); } else { +<<<<<<< HEAD recordsMapUnionOption0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(27, recordsMapUnionOption0); } else { @@ -742,7 +917,11 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List> recordsArrayMap0 = null; @@ -767,6 +946,7 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te Map recordsArrayMapElem0 = null; long chunkLen9 = (decoder.readMapStart()); if (chunkLen9 > 0) { +<<<<<<< HEAD Map recordsArrayMapElemReuse0 = null; if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); @@ -776,6 +956,21 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayMapElem0 = recordsArrayMapElemReuse0; } else { recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter9 = 0; (counter9 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapElemValue': "+ unionIndex20)); } @@ -795,7 +994,15 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te chunkLen9 = (decoder.mapNext()); } while (chunkLen9 > 0); } else { +<<<<<<< HEAD recordsArrayMapElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMap0 .add(recordsArrayMapElem0); } @@ -805,6 +1012,7 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te Map> recordsMapArray0 = null; long chunkLen10 = (decoder.readMapStart()); if (chunkLen10 > 0) { +<<<<<<< HEAD Map> recordsMapArrayReuse0 = null; Object oldMap2 = TestRecord.get(29); if (oldMap2 instanceof Map) { @@ -815,6 +1023,22 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te recordsMapArray0 = recordsMapArrayReuse0; } else { recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter10 = 0; (counter10 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayValueElem': "+ unionIndex21)); } @@ -856,12 +1084,24 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te chunkLen10 = (decoder.mapNext()); } while (chunkLen10 > 0); } else { +<<<<<<< HEAD recordsMapArray0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(29, recordsMapArray0); } +<<<<<<< HEAD private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex22 = (decoder.readIndex()); @@ -892,6 +1132,7 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te Map recordsArrayMapUnionOptionElem0 = null; long chunkLen13 = (decoder.readMapStart()); if (chunkLen13 > 0) { +<<<<<<< HEAD Map recordsArrayMapUnionOptionElemReuse0 = null; if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); @@ -901,6 +1142,21 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; } else { recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter13 = 0; (counter13 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnionOptionElemValue': "+ unionIndex23)); } @@ -920,7 +1180,15 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te chunkLen13 = (decoder.mapNext()); } while (chunkLen13 > 0); } else { +<<<<<<< HEAD recordsArrayMapUnionOptionElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); } @@ -940,6 +1208,7 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te Map> recordsMapArrayUnionOption0 = null; long chunkLen14 = (decoder.readMapStart()); if (chunkLen14 > 0) { +<<<<<<< HEAD Map> recordsMapArrayUnionOptionReuse0 = null; Object oldMap3 = TestRecord.get(31); if (oldMap3 instanceof Map) { @@ -950,6 +1219,22 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; } else { recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter14 = 0; (counter14 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnionOptionValueElem': "+ unionIndex25)); } @@ -991,7 +1280,15 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te chunkLen14 = (decoder.mapNext()); } while (chunkLen14 > 0); } else { +<<<<<<< HEAD recordsMapArrayUnionOption0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(31, recordsMapArrayUnionOption0); } else { @@ -1000,7 +1297,11 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex26 = (decoder.readIndex()); @@ -1009,7 +1310,11 @@ private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(32, null); } else { if (unionIndex26 == 1) { +<<<<<<< HEAD TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder))); +======= + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { if (unionIndex26 == 2) { Utf8 charSequence4; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_SpecificDeserializer_553331077_553331077.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_SpecificDeserializer_553331077_553331077.java index 0a2b911d9..e0a7bb095 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_SpecificDeserializer_553331077_553331077.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/TestRecord_SpecificDeserializer_553331077_553331077.java @@ -14,6 +14,10 @@ import com.linkedin.avro.api.PrimitiveLongList; import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.generated.avro.TestEnum; import com.linkedin.avro.fastserde.generated.avro.TestFixed; import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; @@ -37,6 +41,7 @@ public TestRecord_SpecificDeserializer_553331077_553331077(Schema readerSchema) this.readerSchema = readerSchema; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder) throws IOException { @@ -44,6 +49,15 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.lin } public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; @@ -53,6 +67,7 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); } TestRecord.put(0, (decoder.readInt())); +<<<<<<< HEAD populate_TestRecord0((TestRecord), (decoder)); populate_TestRecord1((TestRecord), (decoder)); populate_TestRecord2((TestRecord), (decoder)); @@ -76,6 +91,31 @@ public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestReco } private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -92,7 +132,11 @@ private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(2, (decoder.readLong())); } +<<<<<<< HEAD private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex1 = (decoder.readIndex()); @@ -109,7 +153,11 @@ private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(4, (decoder.readDouble())); } +<<<<<<< HEAD private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex2 = (decoder.readIndex()); @@ -126,7 +174,11 @@ private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(6, (decoder.readFloat())); } +<<<<<<< HEAD private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex3 = (decoder.readIndex()); @@ -143,7 +195,11 @@ private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(8, (decoder.readBoolean())); } +<<<<<<< HEAD private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex4 = (decoder.readIndex()); @@ -167,7 +223,11 @@ private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(10, byteBuffer0); } +<<<<<<< HEAD private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex5 = (decoder.readIndex()); @@ -198,7 +258,11 @@ private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(12, charSequence0); } +<<<<<<< HEAD private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex6 = (decoder.readIndex()); @@ -232,7 +296,11 @@ private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(14, testFixed1); } +<<<<<<< HEAD private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex7 = (decoder.readIndex()); @@ -292,7 +360,11 @@ private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(16, testFixedArray0); } +<<<<<<< HEAD private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testFixedUnionArray0 = null; @@ -342,7 +414,11 @@ private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(18, Enums.getConstant(TestEnum.class, (decoder.readEnum()))); } +<<<<<<< HEAD private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex9 = (decoder.readIndex()); @@ -378,7 +454,11 @@ private void populate_TestRecord9(com.linkedin.avro.fastserde.generated.avro.Tes TestRecord.put(20, testEnumArray0); } +<<<<<<< HEAD private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testEnumUnionArray0 = null; @@ -421,14 +501,22 @@ private void populate_TestRecord10(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(22, null); } else { if (unionIndex11 == 1) { +<<<<<<< HEAD TestRecord.put(22, deserializeSubRecord0(TestRecord.get(22), (decoder))); +======= + TestRecord.put(22, deserializeSubRecord0(TestRecord.get(22), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'subRecordUnion': "+ unionIndex11)); } } } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord; @@ -455,11 +543,19 @@ public com.linkedin.avro.fastserde.generated.avro.SubRecord deserializeSubRecord throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex12)); } } +<<<<<<< HEAD populate_SubRecord0((SubRecord), (decoder)); return SubRecord; } private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord, Decoder decoder) +======= + populate_SubRecord0((SubRecord), (customization), (decoder)); + return SubRecord; + } + + private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubRecord SubRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex13 = (decoder.readIndex()); @@ -482,10 +578,17 @@ private void populate_SubRecord0(com.linkedin.avro.fastserde.generated.avro.SubR } } +<<<<<<< HEAD private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) throws IOException { TestRecord.put(23, deserializeSubRecord0(TestRecord.get(23), (decoder))); +======= + private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + TestRecord.put(23, deserializeSubRecord0(TestRecord.get(23), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) List recordsArray0 = null; long chunkLen4 = (decoder.readArrayStart()); Object oldArray4 = TestRecord.get(24); @@ -505,19 +608,28 @@ private void populate_TestRecord11(com.linkedin.avro.fastserde.generated.avro.Te if (oldArray4 instanceof GenericArray) { recordsArrayArrayElementReuseVar0 = ((GenericArray) oldArray4).peek(); } +<<<<<<< HEAD recordsArray0 .add(deserializeSubRecord0(recordsArrayArrayElementReuseVar0, (decoder))); +======= + recordsArray0 .add(deserializeSubRecord0(recordsArrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen4 = (decoder.arrayNext()); } TestRecord.put(24, recordsArray0); } +<<<<<<< HEAD private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map recordsMap0 = null; long chunkLen5 = (decoder.readMapStart()); if (chunkLen5 > 0) { +<<<<<<< HEAD Map recordsMapReuse0 = null; Object oldMap0 = TestRecord.get(25); if (oldMap0 instanceof Map) { @@ -528,16 +640,44 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te recordsMap0 = recordsMapReuse0; } else { recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter5 = 0; (counter5 >>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen5 = (decoder.mapNext()); } while (chunkLen5 > 0); } else { +<<<<<<< HEAD recordsMap0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(25, recordsMap0); int unionIndex14 = (decoder.readIndex()); @@ -571,7 +711,11 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayUnionOption0 .add(null); } else { if (unionIndex15 == 1) { +<<<<<<< HEAD recordsArrayUnionOption0 .add(deserializeSubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder))); +======= + recordsArrayUnionOption0 .add(deserializeSubRecord0(recordsArrayUnionOptionArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayUnionOptionElem': "+ unionIndex15)); } @@ -586,7 +730,11 @@ private void populate_TestRecord12(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex16 = (decoder.readIndex()); @@ -598,6 +746,7 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te Map recordsMapUnionOption0 = null; long chunkLen7 = (decoder.readMapStart()); if (chunkLen7 > 0) { +<<<<<<< HEAD Map recordsMapUnionOptionReuse0 = null; Object oldMap1 = TestRecord.get(27); if (oldMap1 instanceof Map) { @@ -608,6 +757,22 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te recordsMapUnionOption0 = recordsMapUnionOptionReuse0; } else { recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter7 = 0; (counter7 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapUnionOptionValue': "+ unionIndex17)); } @@ -627,7 +796,15 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te chunkLen7 = (decoder.mapNext()); } while (chunkLen7 > 0); } else { +<<<<<<< HEAD recordsMapUnionOption0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(27, recordsMapUnionOption0); } else { @@ -656,6 +833,7 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te Map recordsArrayMapElem0 = null; long chunkLen9 = (decoder.readMapStart()); if (chunkLen9 > 0) { +<<<<<<< HEAD Map recordsArrayMapElemReuse0 = null; if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); @@ -665,6 +843,21 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayMapElem0 = recordsArrayMapElemReuse0; } else { recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter9 = 0; (counter9 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapElemValue': "+ unionIndex18)); } @@ -684,7 +881,15 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te chunkLen9 = (decoder.mapNext()); } while (chunkLen9 > 0); } else { +<<<<<<< HEAD recordsArrayMapElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMap0 .add(recordsArrayMapElem0); } @@ -693,12 +898,17 @@ private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(28, recordsArrayMap0); } +<<<<<<< HEAD private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map> recordsMapArray0 = null; long chunkLen10 = (decoder.readMapStart()); if (chunkLen10 > 0) { +<<<<<<< HEAD Map> recordsMapArrayReuse0 = null; Object oldMap2 = TestRecord.get(29); if (oldMap2 instanceof Map) { @@ -709,6 +919,22 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te recordsMapArray0 = recordsMapArrayReuse0; } else { recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter10 = 0; (counter10 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayValueElem': "+ unionIndex19)); } @@ -750,7 +980,15 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te chunkLen10 = (decoder.mapNext()); } while (chunkLen10 > 0); } else { +<<<<<<< HEAD recordsMapArray0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(29, recordsMapArray0); int unionIndex20 = (decoder.readIndex()); @@ -781,6 +1019,7 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te Map recordsArrayMapUnionOptionElem0 = null; long chunkLen13 = (decoder.readMapStart()); if (chunkLen13 > 0) { +<<<<<<< HEAD Map recordsArrayMapUnionOptionElemReuse0 = null; if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); @@ -790,6 +1029,21 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; } else { recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter13 = 0; (counter13 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnionOptionElemValue': "+ unionIndex21)); } @@ -809,7 +1067,15 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te chunkLen13 = (decoder.mapNext()); } while (chunkLen13 > 0); } else { +<<<<<<< HEAD recordsArrayMapUnionOptionElem0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); } @@ -822,7 +1088,11 @@ private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex22 = (decoder.readIndex()); @@ -834,6 +1104,7 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te Map> recordsMapArrayUnionOption0 = null; long chunkLen14 = (decoder.readMapStart()); if (chunkLen14 > 0) { +<<<<<<< HEAD Map> recordsMapArrayUnionOptionReuse0 = null; Object oldMap3 = TestRecord.get(31); if (oldMap3 instanceof Map) { @@ -844,6 +1115,22 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; } else { recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter14 = 0; (counter14 >>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnionOptionValueElem': "+ unionIndex23)); } @@ -885,7 +1176,15 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te chunkLen14 = (decoder.mapNext()); } while (chunkLen14 > 0); } else { +<<<<<<< HEAD recordsMapArrayUnionOption0 = new HashMap>(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } TestRecord.put(31, recordsMapArrayUnionOption0); } else { @@ -898,7 +1197,11 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(32, null); } else { if (unionIndex24 == 1) { +<<<<<<< HEAD TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder))); +======= + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { if (unionIndex24 == 2) { Utf8 charSequence4; @@ -920,7 +1223,11 @@ private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.Te } } +<<<<<<< HEAD private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveBooleanList booleanArray0 = null; @@ -957,7 +1264,11 @@ private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(34, doubleArray0); } +<<<<<<< HEAD private void populate_TestRecord17(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord17(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveFloatList floatArray0 = null; @@ -981,7 +1292,11 @@ private void populate_TestRecord17(com.linkedin.avro.fastserde.generated.avro.Te TestRecord.put(36, intArray0); } +<<<<<<< HEAD private void populate_TestRecord18(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, Decoder decoder) +======= + private void populate_TestRecord18(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { PrimitiveLongList longArray0 = null; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UNION_GenericDeserializer_1971822364_1672473580.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UNION_GenericDeserializer_1971822364_1672473580.java index 015ae6741..6cfaa8cb6 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UNION_GenericDeserializer_1971822364_1672473580.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UNION_GenericDeserializer_1971822364_1672473580.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -19,6 +23,7 @@ public UNION_GenericDeserializer_1971822364_1672473580(Schema readerSchema) { this.recordRecordSchema0 = readerSchema.getTypes().get(1); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -26,6 +31,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UNION_GenericDeserializer_2018567528_1606337179.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UNION_GenericDeserializer_2018567528_1606337179.java index 2aa1beb3d..8d91c50e4 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UNION_GenericDeserializer_2018567528_1606337179.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UNION_GenericDeserializer_2018567528_1606337179.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.GenericArray; import org.apache.avro.generic.IndexedRecord; @@ -23,7 +27,11 @@ public UNION_GenericDeserializer_2018567528_1606337179(Schema readerSchema) { this.arrayArrayElemSchema0 = arrayArraySchema0 .getElementType(); } +<<<<<<< HEAD public List deserialize(List reuse, Decoder decoder) +======= + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List array0 = null; @@ -44,14 +52,22 @@ public List deserialize(List reuse, Decoder decode if ((reuse) instanceof GenericArray) { arrayArrayElementReuseVar0 = ((GenericArray)(reuse)).peek(); } +<<<<<<< HEAD array0 .add(deserializerecord0(arrayArrayElementReuseVar0, (decoder))); +======= + array0 .add(deserializerecord0(arrayArrayElementReuseVar0, (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen0 = (decoder.arrayNext()); } return array0; } +<<<<<<< HEAD public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UNION_GenericDeserializer_568621313_1223705675.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UNION_GenericDeserializer_568621313_1223705675.java index 368ca98dc..0a08ef15c 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UNION_GenericDeserializer_568621313_1223705675.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UNION_GenericDeserializer_568621313_1223705675.java @@ -5,6 +5,10 @@ import java.util.HashMap; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -24,12 +28,17 @@ public UNION_GenericDeserializer_568621313_1223705675(Schema readerSchema) { this.mapMapValueSchema0 = mapMapSchema0 .getValueType(); } +<<<<<<< HEAD public Map deserialize(Map reuse, Decoder decoder) +======= + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map map0 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map mapReuse0 = null; if ((reuse) instanceof Map) { mapReuse0 = ((Map)(reuse)); @@ -39,21 +48,52 @@ public Map deserialize(Map reuse, Deco map0 = mapReuse0; } else { map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 >>>>>> 6f03f254 (Added generated test classes temporarily) } chunkLen0 = (decoder.mapNext()); } while (chunkLen0 > 0); } else { +<<<<<<< HEAD map0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } return map0; } +<<<<<<< HEAD public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java index 41683188a..2b27c9a21 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.generated.avro.MyEnumV1; import com.linkedin.avro.fastserde.generated.avro.MyEnumV2; import com.linkedin.avroutil1.Enums; @@ -19,6 +23,7 @@ public UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_13416 this.readerSchema = readerSchema; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserialize(com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField reuse, Decoder decoder) throws IOException { @@ -26,6 +31,15 @@ public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnum } public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserializeUnionOfRecordsWithSameNameEnumField0(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserialize(com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeUnionOfRecordsWithSameNameEnumField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserializeUnionOfRecordsWithSameNameEnumField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField UnionOfRecordsWithSameNameEnumField; @@ -36,10 +50,17 @@ public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnum } int unionIndex0 = (decoder.readIndex()); if (unionIndex0 == 0) { +<<<<<<< HEAD UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV10(UnionOfRecordsWithSameNameEnumField.get(0), (decoder))); } else { if (unionIndex0 == 1) { UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV20(UnionOfRecordsWithSameNameEnumField.get(0), (decoder))); +======= + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV10(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV20(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); } @@ -47,7 +68,11 @@ public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnum return UnionOfRecordsWithSameNameEnumField; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.MyRecordV1 deserializeMyRecordV10(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.MyRecordV1 deserializeMyRecordV10(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.MyRecordV1 MyRecordV1; @@ -60,7 +85,11 @@ public com.linkedin.avro.fastserde.generated.avro.MyRecordV1 deserializeMyRecord return MyRecordV1; } +<<<<<<< HEAD public com.linkedin.avro.fastserde.generated.avro.MyRecordV2 deserializeMyRecordV20(Object reuse, Decoder decoder) +======= + public com.linkedin.avro.fastserde.generated.avro.MyRecordV2 deserializeMyRecordV20(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { com.linkedin.avro.fastserde.generated.avro.MyRecordV2 MyRecordV2; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/recordName_GenericDeserializer_1743054079_1743054079.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/recordName_GenericDeserializer_1743054079_1743054079.java index cc8f3086e..9722cf5b4 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/recordName_GenericDeserializer_1743054079_1743054079.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/recordName_GenericDeserializer_1743054079_1743054079.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -20,6 +24,7 @@ public recordName_GenericDeserializer_1743054079_1743054079(Schema readerSchema) this.unionField0 = readerSchema.getField("unionField").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -27,6 +32,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializerecordName0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecordName0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecordName0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord recordName; @@ -43,11 +57,19 @@ public IndexedRecord deserializerecordName0(Object reuse, Decoder decoder) charSequence0 = (decoder).readString(null); } recordName.put(0, charSequence0); +<<<<<<< HEAD populate_recordName0((recordName), (decoder)); return recordName; } private void populate_recordName0(IndexedRecord recordName, Decoder decoder) +======= + populate_recordName0((recordName), (customization), (decoder)); + return recordName; + } + + private void populate_recordName0(IndexedRecord recordName, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -56,7 +78,11 @@ private void populate_recordName0(IndexedRecord recordName, Decoder decoder) recordName.put(1, null); } else { if (unionIndex0 == 1) { +<<<<<<< HEAD recordName.put(1, deserializerecordName0(recordName.get(1), (decoder))); +======= + recordName.put(1, deserializerecordName0(recordName.get(1), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); } diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1025741720_1557256887.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1025741720_1557256887.java index 6224c4290..7cd2013ab 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1025741720_1557256887.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1025741720_1557256887.java @@ -5,6 +5,10 @@ import java.util.HashMap; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.AvroTypeException; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -23,6 +27,7 @@ public record_GenericDeserializer_1025741720_1557256887(Schema readerSchema) { this.someInts0 = readerSchema.getField("someInts").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -30,6 +35,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; @@ -46,6 +60,7 @@ record = new org.apache.avro.generic.GenericData.Record(readerSchema); Map someIntsOption0 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map someIntsOptionReuse0 = null; Object oldMap0 = record.get(0); if (oldMap0 instanceof Map) { @@ -56,6 +71,22 @@ record = new org.apache.avro.generic.GenericData.Record(readerSchema); someIntsOption0 = someIntsOptionReuse0; } else { someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 0); } else { +<<<<<<< HEAD someIntsOption0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } record.put(0, someIntsOption0); } else { diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1126840752_2099305627.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1126840752_2099305627.java index 4c47a76a1..38bae15ca 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1126840752_2099305627.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1126840752_2099305627.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.AvroTypeException; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -18,6 +22,7 @@ public record_GenericDeserializer_1126840752_2099305627(Schema readerSchema) { this.readerSchema = readerSchema; } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -25,6 +30,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1191367445_653449771.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1191367445_653449771.java index ae69adb4a..b0ed38d09 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1191367445_653449771.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1191367445_653449771.java @@ -4,6 +4,10 @@ import java.io.IOException; import com.linkedin.avro.api.PrimitiveIntList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; import org.apache.avro.AvroTypeException; import org.apache.avro.Schema; @@ -22,6 +26,7 @@ public record_GenericDeserializer_1191367445_653449771(Schema readerSchema) { this.someInts0 = readerSchema.getField("someInts").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -29,6 +34,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1373882843_1971822364.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1373882843_1971822364.java index a93e5083c..a907b46e1 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1373882843_1971822364.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1373882843_1971822364.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -17,6 +21,7 @@ public record_GenericDeserializer_1373882843_1971822364(Schema readerSchema) { this.readerSchema = readerSchema; } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -24,6 +29,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1556659421_711533897.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1556659421_711533897.java index 3c6a0ba16..9617847b8 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1556659421_711533897.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1556659421_711533897.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.AvroTypeException; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -20,6 +24,7 @@ public record_GenericDeserializer_1556659421_711533897(Schema readerSchema) { this.subRecord0 = readerSchema.getField("subRecord").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -27,6 +32,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; @@ -40,7 +54,11 @@ record = new org.apache.avro.generic.GenericData.Record(readerSchema); throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"subRecord\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"subRecord\",\"fields\":[{\"name\":\"someInt1\",\"type\":\"int\",\"doc\":\"\"},{\"name\":\"someInt2\",\"type\":\"int\",\"doc\":\"\"}]}"); } else { if (unionIndex0 == 1) { +<<<<<<< HEAD record.put(0, deserializesubRecord0(record.get(0), (decoder))); +======= + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex0)); } @@ -48,7 +66,11 @@ record = new org.apache.avro.generic.GenericData.Record(readerSchema); return record; } +<<<<<<< HEAD public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord; @@ -58,11 +80,19 @@ public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) subRecord = new org.apache.avro.generic.GenericData.Record(subRecord0); } subRecord.put(0, (decoder.readInt())); +<<<<<<< HEAD populate_subRecord0((subRecord), (decoder)); return subRecord; } private void populate_subRecord0(IndexedRecord subRecord, Decoder decoder) +======= + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { subRecord.put(1, (decoder.readInt())); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1557256887_1025741720.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1557256887_1025741720.java index bf4f60a0c..d10446eb0 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1557256887_1025741720.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1557256887_1025741720.java @@ -5,6 +5,10 @@ import java.util.HashMap; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -26,6 +30,7 @@ public record_GenericDeserializer_1557256887_1025741720(Schema readerSchema) { this.someIntsMapValueSchema0 = someIntsMapSchema0 .getValueType(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -33,6 +38,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; @@ -44,6 +58,7 @@ record = new org.apache.avro.generic.GenericData.Record(readerSchema); Map someInts1 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map someIntsReuse0 = null; Object oldMap0 = record.get(0); if (oldMap0 instanceof Map) { @@ -54,6 +69,22 @@ record = new org.apache.avro.generic.GenericData.Record(readerSchema); someInts1 = someIntsReuse0; } else { someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 0); } else { +<<<<<<< HEAD someInts1 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } record.put(0, someInts1); return record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1557256887_753570467.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1557256887_753570467.java index f74b88097..701cceb59 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1557256887_753570467.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1557256887_753570467.java @@ -5,6 +5,10 @@ import java.util.HashMap; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -24,6 +28,7 @@ public record_GenericDeserializer_1557256887_753570467(Schema readerSchema) { this.someIntsMapSchema0 = someInts0 .getTypes().get(1); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -31,6 +36,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; @@ -42,6 +56,7 @@ record = new org.apache.avro.generic.GenericData.Record(readerSchema); Map someInts1 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map someIntsReuse0 = null; Object oldMap0 = record.get(0); if (oldMap0 instanceof Map) { @@ -52,6 +67,22 @@ record = new org.apache.avro.generic.GenericData.Record(readerSchema); someInts1 = someIntsReuse0; } else { someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 0); } else { +<<<<<<< HEAD someInts1 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } record.put(0, someInts1); return record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1672473580_1971822364.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1672473580_1971822364.java index 34b30b0b5..eb9c39d8d 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1672473580_1971822364.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1672473580_1971822364.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.AvroTypeException; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -18,7 +22,11 @@ public record_GenericDeserializer_1672473580_1971822364(Schema readerSchema) { this.readerSchema = readerSchema; } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int unionIndex0 = (decoder.readIndex()); @@ -26,14 +34,22 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}"); } else { if (unionIndex0 == 1) { +<<<<<<< HEAD return deserializerecord0((reuse), (decoder)); +======= + return deserializerecord0((reuse), (decoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); } } } +<<<<<<< HEAD public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1971822364_1373882843.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1971822364_1373882843.java index 65297d224..15c1169ca 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1971822364_1373882843.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_1971822364_1373882843.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -19,6 +23,7 @@ public record_GenericDeserializer_1971822364_1373882843(Schema readerSchema) { this.someInt0 = readerSchema.getField("someInt").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -26,6 +31,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_653449771_1191367445.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_653449771_1191367445.java index 5d235c52a..89c2755bd 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_653449771_1191367445.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_653449771_1191367445.java @@ -4,6 +4,10 @@ import java.io.IOException; import com.linkedin.avro.api.PrimitiveIntList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -23,6 +27,7 @@ public record_GenericDeserializer_653449771_1191367445(Schema readerSchema) { this.someIntsArraySchema0 = someInts0 .getTypes().get(1); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -30,6 +35,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_653449771_813379571.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_653449771_813379571.java index 7f229c2e6..6ce4a9533 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_653449771_813379571.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_653449771_813379571.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -24,6 +28,7 @@ public record_GenericDeserializer_653449771_813379571(Schema readerSchema) { this.someIntsArrayElemSchema0 = someIntsArraySchema0 .getElementType(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -31,6 +36,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_711533897_1556659421.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_711533897_1556659421.java index 57c1517b4..69aeb45ab 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_711533897_1556659421.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_711533897_1556659421.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Decoder; @@ -21,6 +25,7 @@ public record_GenericDeserializer_711533897_1556659421(Schema readerSchema) { this.subRecordRecordSchema0 = subRecord0 .getTypes().get(1); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -28,6 +33,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; @@ -36,11 +50,19 @@ record = ((IndexedRecord)(reuse)); } else { record = new org.apache.avro.generic.GenericData.Record(readerSchema); } +<<<<<<< HEAD record.put(0, deserializesubRecord0(record.get(0), (decoder))); return record; } public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) +======= + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); + return record; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord subRecord; @@ -50,11 +72,19 @@ public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder) subRecord = new org.apache.avro.generic.GenericData.Record(subRecordRecordSchema0); } subRecord.put(0, (decoder.readInt())); +<<<<<<< HEAD populate_subRecord0((subRecord), (decoder)); return subRecord; } private void populate_subRecord0(IndexedRecord subRecord, Decoder decoder) +======= + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { subRecord.put(1, (decoder.readInt())); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_753570467_1557256887.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_753570467_1557256887.java index 693567e25..45495acf3 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_753570467_1557256887.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_753570467_1557256887.java @@ -5,6 +5,10 @@ import java.util.HashMap; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.AvroTypeException; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -23,6 +27,7 @@ public record_GenericDeserializer_753570467_1557256887(Schema readerSchema) { this.someInts0 = readerSchema.getField("someInts").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -30,6 +35,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; @@ -46,6 +60,7 @@ record = new org.apache.avro.generic.GenericData.Record(readerSchema); Map someIntsOption0 = null; long chunkLen0 = (decoder.readMapStart()); if (chunkLen0 > 0) { +<<<<<<< HEAD Map someIntsOptionReuse0 = null; Object oldMap0 = record.get(0); if (oldMap0 instanceof Map) { @@ -56,6 +71,22 @@ record = new org.apache.avro.generic.GenericData.Record(readerSchema); someIntsOption0 = someIntsOptionReuse0; } else { someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } do { for (int counter0 = 0; (counter0 0); } else { +<<<<<<< HEAD someIntsOption0 = new HashMap(0); +======= + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) } record.put(0, someIntsOption0); } else { diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_813379571_653449771.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_813379571_653449771.java index ea4ff8093..72f8d19ca 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_813379571_653449771.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/record_GenericDeserializer_813379571_653449771.java @@ -4,6 +4,10 @@ import java.io.IOException; import com.linkedin.avro.api.PrimitiveIntList; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; import org.apache.avro.AvroTypeException; import org.apache.avro.Schema; @@ -23,6 +27,7 @@ public record_GenericDeserializer_813379571_653449771(Schema readerSchema) { this.someInts0 = readerSchema.getField("someInts").schema(); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -30,6 +35,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializerecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/testRecord_GenericDeserializer_1146484089_1256982207.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/testRecord_GenericDeserializer_1146484089_1256982207.java index 5f36ad64b..460846579 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/testRecord_GenericDeserializer_1146484089_1256982207.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_11/testRecord_GenericDeserializer_1146484089_1256982207.java @@ -6,6 +6,10 @@ import java.util.HashMap; import java.util.Map; import com.linkedin.avro.fastserde.FastDeserializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.AvroTypeException; import org.apache.avro.Schema; import org.apache.avro.generic.GenericEnumSymbol; @@ -30,6 +34,7 @@ public testRecord_GenericDeserializer_1146484089_1256982207(Schema readerSchema) this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); } +<<<<<<< HEAD public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) throws IOException { @@ -37,6 +42,15 @@ public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder) } public IndexedRecord deserializetestRecord0(Object reuse, Decoder decoder) +======= + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializetestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializetestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord testRecord; diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_BOOLEAN_GenericSerializer_869749973.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_BOOLEAN_GenericSerializer_869749973.java index e4dd3fc12..328559a7f 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_BOOLEAN_GenericSerializer_869749973.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_BOOLEAN_GenericSerializer_869749973.java @@ -5,6 +5,10 @@ import java.util.List; import com.linkedin.avro.api.PrimitiveBooleanList; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.io.Encoder; public class Array_of_BOOLEAN_GenericSerializer_869749973 @@ -12,7 +16,11 @@ public class Array_of_BOOLEAN_GenericSerializer_869749973 { +<<<<<<< HEAD public void serialize(List data, Encoder encoder) +======= + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeArrayStart(); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_DOUBLE_GenericSerializer_18760307.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_DOUBLE_GenericSerializer_18760307.java index 48816d57e..621c75486 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_DOUBLE_GenericSerializer_18760307.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_DOUBLE_GenericSerializer_18760307.java @@ -5,6 +5,10 @@ import java.util.List; import com.linkedin.avro.api.PrimitiveDoubleList; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.io.Encoder; public class Array_of_DOUBLE_GenericSerializer_18760307 @@ -12,7 +16,11 @@ public class Array_of_DOUBLE_GenericSerializer_18760307 { +<<<<<<< HEAD public void serialize(List data, Encoder encoder) +======= + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeArrayStart(); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_FLOAT_GenericSerializer_1012670397.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_FLOAT_GenericSerializer_1012670397.java index 52bb9253b..ed4b0fa73 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_FLOAT_GenericSerializer_1012670397.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_FLOAT_GenericSerializer_1012670397.java @@ -6,6 +6,10 @@ import com.linkedin.avro.api.PrimitiveFloatList; import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.io.Encoder; public class Array_of_FLOAT_GenericSerializer_1012670397 @@ -13,7 +17,11 @@ public class Array_of_FLOAT_GenericSerializer_1012670397 { +<<<<<<< HEAD public void serialize(List data, Encoder encoder) +======= + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeArrayStart(); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_INT_GenericSerializer_1012089072.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_INT_GenericSerializer_1012089072.java index 8185166fd..bebd8704d 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_INT_GenericSerializer_1012089072.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_INT_GenericSerializer_1012089072.java @@ -5,6 +5,10 @@ import java.util.List; import com.linkedin.avro.api.PrimitiveIntList; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.io.Encoder; public class Array_of_INT_GenericSerializer_1012089072 @@ -12,7 +16,11 @@ public class Array_of_INT_GenericSerializer_1012089072 { +<<<<<<< HEAD public void serialize(List data, Encoder encoder) +======= + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeArrayStart(); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_LONG_GenericSerializer_325099267.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_LONG_GenericSerializer_325099267.java index efccd52e4..131f38714 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_LONG_GenericSerializer_325099267.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_LONG_GenericSerializer_325099267.java @@ -5,6 +5,10 @@ import java.util.List; import com.linkedin.avro.api.PrimitiveLongList; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.io.Encoder; public class Array_of_LONG_GenericSerializer_325099267 @@ -12,7 +16,11 @@ public class Array_of_LONG_GenericSerializer_325099267 { +<<<<<<< HEAD public void serialize(List data, Encoder encoder) +======= + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeArrayStart(); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_UNION_GenericSerializer_777827233.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_UNION_GenericSerializer_777827233.java index b34eb1e05..eb90c02aa 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_UNION_GenericSerializer_777827233.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_UNION_GenericSerializer_777827233.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; import org.apache.avro.util.Utf8; @@ -13,7 +17,11 @@ public class Array_of_UNION_GenericSerializer_777827233 { +<<<<<<< HEAD public void serialize(List data, Encoder encoder) +======= + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeArrayStart(); @@ -31,7 +39,11 @@ public void serialize(List data, Encoder encoder) } else { if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { (encoder).writeIndex(1); +<<<<<<< HEAD serializeRecord0(((IndexedRecord) union0), (encoder)); +======= + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } } } @@ -40,7 +52,11 @@ public void serialize(List data, Encoder encoder) } @SuppressWarnings("unchecked") +<<<<<<< HEAD public void serializeRecord0(IndexedRecord data, Encoder encoder) +======= + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { CharSequence field0 = ((CharSequence) data.get(0)); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_record_GenericSerializer_477614132.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_record_GenericSerializer_477614132.java index 8aa0633f7..f55fcd687 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_record_GenericSerializer_477614132.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Array_of_record_GenericSerializer_477614132.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; import org.apache.avro.util.Utf8; @@ -13,7 +17,11 @@ public class Array_of_record_GenericSerializer_477614132 { +<<<<<<< HEAD public void serialize(List data, Encoder encoder) +======= + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeArrayStart(); @@ -25,14 +33,22 @@ public void serialize(List data, Encoder encoder) (encoder).startItem(); IndexedRecord record0 = null; record0 = ((List ) data).get(counter0); +<<<<<<< HEAD serializeRecord0(record0, (encoder)); +======= + serializeRecord0(record0, (encoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } } (encoder).writeArrayEnd(); } @SuppressWarnings("unchecked") +<<<<<<< HEAD public void serializeRecord0(IndexedRecord data, Encoder encoder) +======= + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { CharSequence field0 = ((CharSequence) data.get(0)); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java index 015350bae..3ac059366 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; @@ -11,6 +15,7 @@ public class FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_Gener { +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -526,6 +531,523 @@ public void serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeReco @SuppressWarnings("unchecked") private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(1))); @@ -533,7 +1055,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(3))); @@ -541,7 +1067,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(5))); @@ -549,7 +1079,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(7))); @@ -557,7 +1091,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(9))); @@ -565,7 +1103,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(11))); @@ -573,7 +1115,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(13))); @@ -581,7 +1127,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(15))); @@ -589,7 +1139,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(17))); @@ -597,7 +1151,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(19))); @@ -605,7 +1163,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(21))); @@ -613,7 +1175,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(23))); @@ -621,7 +1187,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(25))); @@ -629,7 +1199,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(27))); @@ -637,7 +1211,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(29))); @@ -645,7 +1223,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(31))); @@ -653,7 +1235,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(33))); @@ -661,7 +1247,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(35))); @@ -669,7 +1259,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(37))); @@ -677,7 +1271,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(39))); @@ -685,7 +1283,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(41))); @@ -693,7 +1295,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(43))); @@ -701,7 +1307,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(45))); @@ -709,7 +1319,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(47))); @@ -717,7 +1331,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(49))); @@ -725,7 +1343,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(51))); @@ -733,7 +1355,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(53))); @@ -741,7 +1367,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(55))); @@ -749,7 +1379,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(57))); @@ -757,7 +1391,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(59))); @@ -765,7 +1403,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(61))); @@ -773,7 +1415,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(63))); @@ -781,7 +1427,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(65))); @@ -789,7 +1439,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(67))); @@ -797,7 +1451,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(69))); @@ -805,7 +1463,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(71))); @@ -813,7 +1475,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(73))); @@ -821,7 +1487,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(75))); @@ -829,7 +1499,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(77))); @@ -837,7 +1511,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(79))); @@ -845,7 +1523,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(81))); @@ -853,7 +1535,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(83))); @@ -861,7 +1547,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(85))); @@ -869,7 +1559,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(87))); @@ -877,7 +1571,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(89))); @@ -885,7 +1583,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(91))); @@ -893,7 +1595,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(93))); @@ -901,7 +1607,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(95))); @@ -909,7 +1619,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(97))); @@ -917,7 +1631,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(99))); @@ -925,7 +1643,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(101))); @@ -933,7 +1655,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(103))); @@ -941,7 +1667,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(105))); @@ -949,7 +1679,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(107))); @@ -957,7 +1691,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(109))); @@ -965,7 +1703,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(111))); @@ -973,7 +1715,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(113))); @@ -981,7 +1727,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(115))); @@ -989,7 +1739,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(117))); @@ -997,7 +1751,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(119))); @@ -1005,7 +1763,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(121))); @@ -1013,7 +1775,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(123))); @@ -1021,7 +1787,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(125))); @@ -1029,7 +1799,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(127))); @@ -1037,7 +1811,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(129))); @@ -1045,7 +1823,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(131))); @@ -1053,7 +1835,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(133))); @@ -1061,7 +1847,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(135))); @@ -1069,7 +1859,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(137))); @@ -1077,7 +1871,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(139))); @@ -1085,7 +1883,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(141))); @@ -1093,7 +1895,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(143))); @@ -1101,7 +1907,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(145))); @@ -1109,7 +1919,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(147))); @@ -1117,7 +1931,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(149))); @@ -1125,7 +1943,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(151))); @@ -1133,7 +1955,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(153))); @@ -1141,7 +1967,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(155))); @@ -1149,7 +1979,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(157))); @@ -1157,7 +1991,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(159))); @@ -1165,7 +2003,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(161))); @@ -1173,7 +2015,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(163))); @@ -1181,7 +2027,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(165))); @@ -1189,7 +2039,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(167))); @@ -1197,7 +2051,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(169))); @@ -1205,7 +2063,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(171))); @@ -1213,7 +2075,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(173))); @@ -1221,7 +2087,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(175))); @@ -1229,7 +2099,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(177))); @@ -1237,7 +2111,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(179))); @@ -1245,7 +2123,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(181))); @@ -1253,7 +2135,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(183))); @@ -1261,7 +2147,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(185))); @@ -1269,7 +2159,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(187))); @@ -1277,7 +2171,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(189))); @@ -1285,7 +2183,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(191))); @@ -1293,7 +2195,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(193))); @@ -1301,7 +2207,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(195))); @@ -1309,7 +2219,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(197))); @@ -1317,7 +2231,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(199))); @@ -1325,7 +2243,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(201))); @@ -1333,7 +2255,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(203))); @@ -1341,7 +2267,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(205))); @@ -1349,7 +2279,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(207))); @@ -1357,7 +2291,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(209))); @@ -1365,7 +2303,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(211))); @@ -1373,7 +2315,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(213))); @@ -1381,7 +2327,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(215))); @@ -1389,7 +2339,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(217))); @@ -1397,7 +2351,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(219))); @@ -1405,7 +2363,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(221))); @@ -1413,7 +2375,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(223))); @@ -1421,7 +2387,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(225))); @@ -1429,7 +2399,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(227))); @@ -1437,7 +2411,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(229))); @@ -1445,7 +2423,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(231))); @@ -1453,7 +2435,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(233))); @@ -1461,7 +2447,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(235))); @@ -1469,7 +2459,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(237))); @@ -1477,7 +2471,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(239))); @@ -1485,7 +2483,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(241))); @@ -1493,7 +2495,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(243))); @@ -1501,7 +2507,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(245))); @@ -1509,7 +2519,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(247))); @@ -1517,7 +2531,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(249))); @@ -1525,7 +2543,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(251))); @@ -1533,7 +2555,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(253))); @@ -1541,7 +2567,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(255))); @@ -1549,7 +2579,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(257))); @@ -1557,7 +2591,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(259))); @@ -1565,7 +2603,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(261))); @@ -1573,7 +2615,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(263))); @@ -1581,7 +2627,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(265))); @@ -1589,7 +2639,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(267))); @@ -1597,7 +2651,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(269))); @@ -1605,7 +2663,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(271))); @@ -1613,7 +2675,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(273))); @@ -1621,7 +2687,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(275))); @@ -1629,7 +2699,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(277))); @@ -1637,7 +2711,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(279))); @@ -1645,7 +2723,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(281))); @@ -1653,7 +2735,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(283))); @@ -1661,7 +2747,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(285))); @@ -1669,7 +2759,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(287))); @@ -1677,7 +2771,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(289))); @@ -1685,7 +2783,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(291))); @@ -1693,7 +2795,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(293))); @@ -1701,7 +2807,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(295))); @@ -1709,7 +2819,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(297))); @@ -1717,7 +2831,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(299))); @@ -1725,7 +2843,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(301))); @@ -1733,7 +2855,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(303))); @@ -1741,7 +2867,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(305))); @@ -1749,7 +2879,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(307))); @@ -1757,7 +2891,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(309))); @@ -1765,7 +2903,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(311))); @@ -1773,7 +2915,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(313))); @@ -1781,7 +2927,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(315))); @@ -1789,7 +2939,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(317))); @@ -1797,7 +2951,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(319))); @@ -1805,7 +2963,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(321))); @@ -1813,7 +2975,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(323))); @@ -1821,7 +2987,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(325))); @@ -1829,7 +2999,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(327))); @@ -1837,7 +3011,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(329))); @@ -1845,7 +3023,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(331))); @@ -1853,7 +3035,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(333))); @@ -1861,7 +3047,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(335))); @@ -1869,7 +3059,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(337))); @@ -1877,7 +3071,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(339))); @@ -1885,7 +3083,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(341))); @@ -1893,7 +3095,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(343))); @@ -1901,7 +3107,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(345))); @@ -1909,7 +3119,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(347))); @@ -1917,7 +3131,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(349))); @@ -1925,7 +3143,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(351))); @@ -1933,7 +3155,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(353))); @@ -1941,7 +3167,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(355))); @@ -1949,7 +3179,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(357))); @@ -1957,7 +3191,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(359))); @@ -1965,7 +3203,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(361))); @@ -1973,7 +3215,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(363))); @@ -1981,7 +3227,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(365))); @@ -1989,7 +3239,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(367))); @@ -1997,7 +3251,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(369))); @@ -2005,7 +3263,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(371))); @@ -2013,7 +3275,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(373))); @@ -2021,7 +3287,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(375))); @@ -2029,7 +3299,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(377))); @@ -2037,7 +3311,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(379))); @@ -2045,7 +3323,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(381))); @@ -2053,7 +3335,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(383))); @@ -2061,7 +3347,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(385))); @@ -2069,7 +3359,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(387))); @@ -2077,7 +3371,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(389))); @@ -2085,7 +3383,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(391))); @@ -2093,7 +3395,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(393))); @@ -2101,7 +3407,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(395))); @@ -2109,7 +3419,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(397))); @@ -2117,7 +3431,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(399))); @@ -2125,7 +3443,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(401))); @@ -2133,7 +3455,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(403))); @@ -2141,7 +3467,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(405))); @@ -2149,7 +3479,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(407))); @@ -2157,7 +3491,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(409))); @@ -2165,7 +3503,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(411))); @@ -2173,7 +3515,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(413))); @@ -2181,7 +3527,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(415))); @@ -2189,7 +3539,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(417))); @@ -2197,7 +3551,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(419))); @@ -2205,7 +3563,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(421))); @@ -2213,7 +3575,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(423))); @@ -2221,7 +3587,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(425))); @@ -2229,7 +3599,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(427))); @@ -2237,7 +3611,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(429))); @@ -2245,7 +3623,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(431))); @@ -2253,7 +3635,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(433))); @@ -2261,7 +3647,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(435))); @@ -2269,7 +3659,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(437))); @@ -2277,7 +3671,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(439))); @@ -2285,7 +3683,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(441))); @@ -2293,7 +3695,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(443))); @@ -2301,7 +3707,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(445))); @@ -2309,7 +3719,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(447))); @@ -2317,7 +3731,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(449))); @@ -2325,7 +3743,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(451))); @@ -2333,7 +3755,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(453))); @@ -2341,7 +3767,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(455))); @@ -2349,7 +3779,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(457))); @@ -2357,7 +3791,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(459))); @@ -2365,7 +3803,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(461))); @@ -2373,7 +3815,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(463))); @@ -2381,7 +3827,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(465))); @@ -2389,7 +3839,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(467))); @@ -2397,7 +3851,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(469))); @@ -2405,7 +3863,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(471))); @@ -2413,7 +3875,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(473))); @@ -2421,7 +3887,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(475))); @@ -2429,7 +3899,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(477))); @@ -2437,7 +3911,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(479))); @@ -2445,7 +3923,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(481))); @@ -2453,7 +3935,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(483))); @@ -2461,7 +3947,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(485))); @@ -2469,7 +3959,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(487))); @@ -2477,7 +3971,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(489))); @@ -2485,7 +3983,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(491))); @@ -2493,7 +3995,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(493))); @@ -2501,7 +4007,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(495))); @@ -2509,7 +4019,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(497))); @@ -2517,7 +4031,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(499))); @@ -2525,7 +4043,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(501))); @@ -2533,7 +4055,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(503))); @@ -2541,7 +4067,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(505))); @@ -2549,7 +4079,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(507))); @@ -2557,7 +4091,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(509))); @@ -2565,7 +4103,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(511))); @@ -2573,7 +4115,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(513))); @@ -2581,7 +4127,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(515))); @@ -2589,7 +4139,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(517))); @@ -2597,7 +4151,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(519))); @@ -2605,7 +4163,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(521))); @@ -2613,7 +4175,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(523))); @@ -2621,7 +4187,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(525))); @@ -2629,7 +4199,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(527))); @@ -2637,7 +4211,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(529))); @@ -2645,7 +4223,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(531))); @@ -2653,7 +4235,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(533))); @@ -2661,7 +4247,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(535))); @@ -2669,7 +4259,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(537))); @@ -2677,7 +4271,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(539))); @@ -2685,7 +4283,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(541))); @@ -2693,7 +4295,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(543))); @@ -2701,7 +4307,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(545))); @@ -2709,7 +4319,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(547))); @@ -2717,7 +4331,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(549))); @@ -2725,7 +4343,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(551))); @@ -2733,7 +4355,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(553))); @@ -2741,7 +4367,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(555))); @@ -2749,7 +4379,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(557))); @@ -2757,7 +4391,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(559))); @@ -2765,7 +4403,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(561))); @@ -2773,7 +4415,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(563))); @@ -2781,7 +4427,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(565))); @@ -2789,7 +4439,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(567))); @@ -2797,7 +4451,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(569))); @@ -2805,7 +4463,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(571))); @@ -2813,7 +4475,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(573))); @@ -2821,7 +4487,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(575))); @@ -2829,7 +4499,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(577))); @@ -2837,7 +4511,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(579))); @@ -2845,7 +4523,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(581))); @@ -2853,7 +4535,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(583))); @@ -2861,7 +4547,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(585))); @@ -2869,7 +4559,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(587))); @@ -2877,7 +4571,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(589))); @@ -2885,7 +4583,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(591))); @@ -2893,7 +4595,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(593))); @@ -2901,7 +4607,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(595))); @@ -2909,7 +4619,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(597))); @@ -2917,7 +4631,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(599))); @@ -2925,7 +4643,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(601))); @@ -2933,7 +4655,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(603))); @@ -2941,7 +4667,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(605))); @@ -2949,7 +4679,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(607))); @@ -2957,7 +4691,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(609))); @@ -2965,7 +4703,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(611))); @@ -2973,7 +4715,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(613))); @@ -2981,7 +4727,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(615))); @@ -2989,7 +4739,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(617))); @@ -2997,7 +4751,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(619))); @@ -3005,7 +4763,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(621))); @@ -3013,7 +4775,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(623))); @@ -3021,7 +4787,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(625))); @@ -3029,7 +4799,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(627))); @@ -3037,7 +4811,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(629))); @@ -3045,7 +4823,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(631))); @@ -3053,7 +4835,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(633))); @@ -3061,7 +4847,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(635))); @@ -3069,7 +4859,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(637))); @@ -3077,7 +4871,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(639))); @@ -3085,7 +4883,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(641))); @@ -3093,7 +4895,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(643))); @@ -3101,7 +4907,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(645))); @@ -3109,7 +4919,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(647))); @@ -3117,7 +4931,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(649))); @@ -3125,7 +4943,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(651))); @@ -3133,7 +4955,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(653))); @@ -3141,7 +4967,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(655))); @@ -3149,7 +4979,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(657))); @@ -3157,7 +4991,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(659))); @@ -3165,7 +5003,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(661))); @@ -3173,7 +5015,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(663))); @@ -3181,7 +5027,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(665))); @@ -3189,7 +5039,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(667))); @@ -3197,7 +5051,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(669))); @@ -3205,7 +5063,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(671))); @@ -3213,7 +5075,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(673))); @@ -3221,7 +5087,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(675))); @@ -3229,7 +5099,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(677))); @@ -3237,7 +5111,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(679))); @@ -3245,7 +5123,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(681))); @@ -3253,7 +5135,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(683))); @@ -3261,7 +5147,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(685))); @@ -3269,7 +5159,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(687))); @@ -3277,7 +5171,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(689))); @@ -3285,7 +5183,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(691))); @@ -3293,7 +5195,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(693))); @@ -3301,7 +5207,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(695))); @@ -3309,7 +5219,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(697))); @@ -3317,7 +5231,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(699))); @@ -3325,7 +5243,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(701))); @@ -3333,7 +5255,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(703))); @@ -3341,7 +5267,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(705))); @@ -3349,7 +5279,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(707))); @@ -3357,7 +5291,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(709))); @@ -3365,7 +5303,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(711))); @@ -3373,7 +5315,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(713))); @@ -3381,7 +5327,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(715))); @@ -3389,7 +5339,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(717))); @@ -3397,7 +5351,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(719))); @@ -3405,7 +5363,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(721))); @@ -3413,7 +5375,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(723))); @@ -3421,7 +5387,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(725))); @@ -3429,7 +5399,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(727))); @@ -3437,7 +5411,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(729))); @@ -3445,7 +5423,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(731))); @@ -3453,7 +5435,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(733))); @@ -3461,7 +5447,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(735))); @@ -3469,7 +5459,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(737))); @@ -3477,7 +5471,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(739))); @@ -3485,7 +5483,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(741))); @@ -3493,7 +5495,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(743))); @@ -3501,7 +5507,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(745))); @@ -3509,7 +5519,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(747))); @@ -3517,7 +5531,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(749))); @@ -3525,7 +5543,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(751))); @@ -3533,7 +5555,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(753))); @@ -3541,7 +5567,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(755))); @@ -3549,7 +5579,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(757))); @@ -3557,7 +5591,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(759))); @@ -3565,7 +5603,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(761))); @@ -3573,7 +5615,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(763))); @@ -3581,7 +5627,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(765))); @@ -3589,7 +5639,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(767))); @@ -3597,7 +5651,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(769))); @@ -3605,7 +5663,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(771))); @@ -3613,7 +5675,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(773))); @@ -3621,7 +5687,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(775))); @@ -3629,7 +5699,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(777))); @@ -3637,7 +5711,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(779))); @@ -3645,7 +5723,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(781))); @@ -3653,7 +5735,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(783))); @@ -3661,7 +5747,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(785))); @@ -3669,7 +5759,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(787))); @@ -3677,7 +5771,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(789))); @@ -3685,7 +5783,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(791))); @@ -3693,7 +5795,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(793))); @@ -3701,7 +5807,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(795))); @@ -3709,7 +5819,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(797))); @@ -3717,7 +5831,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(799))); @@ -3725,7 +5843,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(801))); @@ -3733,7 +5855,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(803))); @@ -3741,7 +5867,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(805))); @@ -3749,7 +5879,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(807))); @@ -3757,7 +5891,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(809))); @@ -3765,7 +5903,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(811))); @@ -3773,7 +5915,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(813))); @@ -3781,7 +5927,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(815))); @@ -3789,7 +5939,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(817))); @@ -3797,7 +5951,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(819))); @@ -3805,7 +5963,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(821))); @@ -3813,7 +5975,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(823))); @@ -3821,7 +5987,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(825))); @@ -3829,7 +5999,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(827))); @@ -3837,7 +6011,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(829))); @@ -3845,7 +6023,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(831))); @@ -3853,7 +6035,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(833))); @@ -3861,7 +6047,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(835))); @@ -3869,7 +6059,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(837))); @@ -3877,7 +6071,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(839))); @@ -3885,7 +6083,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(841))); @@ -3893,7 +6095,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(843))); @@ -3901,7 +6107,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(845))); @@ -3909,7 +6119,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(847))); @@ -3917,7 +6131,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(849))); @@ -3925,7 +6143,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(851))); @@ -3933,7 +6155,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(853))); @@ -3941,7 +6167,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(855))); @@ -3949,7 +6179,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(857))); @@ -3957,7 +6191,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(859))); @@ -3965,7 +6203,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(861))); @@ -3973,7 +6215,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(863))); @@ -3981,7 +6227,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(865))); @@ -3989,7 +6239,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(867))); @@ -3997,7 +6251,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(869))); @@ -4005,7 +6263,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(871))); @@ -4013,7 +6275,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(873))); @@ -4021,7 +6287,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(875))); @@ -4029,7 +6299,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(877))); @@ -4037,7 +6311,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(879))); @@ -4045,7 +6323,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(881))); @@ -4053,7 +6335,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(883))); @@ -4061,7 +6347,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(885))); @@ -4069,7 +6359,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(887))); @@ -4077,7 +6371,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(889))); @@ -4085,7 +6383,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(891))); @@ -4093,7 +6395,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(893))); @@ -4101,7 +6407,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(895))); @@ -4109,7 +6419,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(897))); @@ -4117,7 +6431,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(899))); @@ -4125,7 +6443,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(901))); @@ -4133,7 +6455,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(903))); @@ -4141,7 +6467,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(905))); @@ -4149,7 +6479,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(907))); @@ -4157,7 +6491,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(909))); @@ -4165,7 +6503,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(911))); @@ -4173,7 +6515,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(913))); @@ -4181,7 +6527,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(915))); @@ -4189,7 +6539,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(917))); @@ -4197,7 +6551,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(919))); @@ -4205,7 +6563,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(921))); @@ -4213,7 +6575,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(923))); @@ -4221,7 +6587,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(925))); @@ -4229,7 +6599,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(927))); @@ -4237,7 +6611,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(929))); @@ -4245,7 +6623,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(931))); @@ -4253,7 +6635,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(933))); @@ -4261,7 +6647,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(935))); @@ -4269,7 +6659,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(937))); @@ -4277,7 +6671,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(939))); @@ -4285,7 +6683,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(941))); @@ -4293,7 +6695,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(943))); @@ -4301,7 +6707,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(945))); @@ -4309,7 +6719,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(947))); @@ -4317,7 +6731,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(949))); @@ -4325,7 +6743,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(951))); @@ -4333,7 +6755,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(953))); @@ -4341,7 +6767,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(955))); @@ -4349,7 +6779,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(957))); @@ -4357,7 +6791,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(959))); @@ -4365,7 +6803,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(961))); @@ -4373,7 +6815,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(963))); @@ -4381,7 +6827,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(965))); @@ -4389,7 +6839,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(967))); @@ -4397,7 +6851,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(969))); @@ -4405,7 +6863,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(971))); @@ -4413,7 +6875,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(973))); @@ -4421,7 +6887,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(975))); @@ -4429,7 +6899,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(977))); @@ -4437,7 +6911,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(979))); @@ -4445,7 +6923,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(981))); @@ -4453,7 +6935,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(983))); @@ -4461,7 +6947,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(985))); @@ -4469,7 +6959,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(987))); @@ -4477,7 +6971,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(989))); @@ -4485,7 +6983,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(991))); @@ -4493,7 +6995,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(993))); @@ -4501,7 +7007,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(995))); @@ -4509,7 +7019,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(997))); @@ -4517,7 +7031,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRe } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(999))); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java index 66f7bc80c..95b814683 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.GenericEnumSymbol; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; @@ -13,6 +17,7 @@ public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnum { +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -21,6 +26,16 @@ public void serialize(IndexedRecord data, Encoder encoder) @SuppressWarnings("unchecked") public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int valueToWrite0; @@ -31,12 +46,21 @@ public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecord valueToWrite0 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).toString()); } (encoder).writeEnum(valueToWrite0); +<<<<<<< HEAD serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder)); serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums1(data, (encoder)); } @SuppressWarnings("unchecked") private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder) +======= + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { GenericEnumSymbol testEnumUnion0 = ((GenericEnumSymbol) data.get(1)); @@ -78,7 +102,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericReco } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums1(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testEnumUnionArray0 = ((List ) data.get(3)); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java index 5fce5b2df..849ca7496 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.GenericFixed; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; @@ -13,6 +17,7 @@ public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixe { +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -30,6 +35,25 @@ public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecord @SuppressWarnings("unchecked") private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { GenericFixed testFixedUnion0 = ((GenericFixed) data.get(1)); @@ -57,7 +81,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericReco } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed1(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List testFixedUnionArray0 = ((List ) data.get(3)); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java index f99a1a390..f03c7a8b7 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; import org.apache.avro.util.Utf8; @@ -12,6 +16,7 @@ public class FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_G { +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -20,6 +25,16 @@ public void serialize(IndexedRecord data, Encoder encoder) @SuppressWarnings("unchecked") public void serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object union0 = ((Object) data.get(0)); @@ -29,7 +44,11 @@ public void serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoic } else { if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { (encoder).writeIndex(1); +<<<<<<< HEAD serializeSubRecord0(((IndexedRecord) union0), (encoder)); +======= + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } else { if (union0 instanceof CharSequence) { (encoder).writeIndex(2); @@ -49,7 +68,11 @@ public void serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoic } @SuppressWarnings("unchecked") +<<<<<<< HEAD public void serializeSubRecord0(IndexedRecord data, Encoder encoder) +======= + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { CharSequence subField0 = ((CharSequence) data.get(0)); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java index 5a6e2cf33..80ca6ccb8 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.nio.ByteBuffer; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; import org.apache.avro.util.Utf8; @@ -13,6 +17,7 @@ public class FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSer { +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -35,6 +40,30 @@ public void serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(I @SuppressWarnings("unchecked") private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Integer testIntUnion0 = ((Integer) data.get(1)); @@ -56,7 +85,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0 } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { if (((CharSequence) data.get(3)) instanceof Utf8) { @@ -79,7 +112,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1 } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeLong(((Long) data.get(5))); @@ -94,7 +131,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2 } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeDouble(((Double) data.get(7))); @@ -109,7 +150,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3 } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeFloat(((Float) data.get(9))); @@ -124,7 +169,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4 } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeBoolean(((Boolean) data.get(11))); @@ -139,7 +188,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5 } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeBytes(((ByteBuffer) data.get(13))); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java index 09834ebc2..3fc592a16 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; import org.apache.avro.util.Utf8; @@ -12,6 +16,7 @@ public class FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_Gener { +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -20,6 +25,16 @@ public void serialize(IndexedRecord data, Encoder encoder) @SuppressWarnings("unchecked") public void serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object union_field0 = ((Object) data.get(0)); @@ -29,18 +44,30 @@ public void serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionInd } else { if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record1".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { (encoder).writeIndex(1); +<<<<<<< HEAD serializeRecord10(((IndexedRecord) union_field0), (encoder)); } else { if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record2".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { (encoder).writeIndex(2); serializeRecord20(((IndexedRecord) union_field0), (encoder)); +======= + serializeRecord10(((IndexedRecord) union_field0), (encoder), (customization)); + } else { + if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record2".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { + (encoder).writeIndex(2); + serializeRecord20(((IndexedRecord) union_field0), (encoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } } } } @SuppressWarnings("unchecked") +<<<<<<< HEAD public void serializeRecord10(IndexedRecord data, Encoder encoder) +======= + public void serializeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { if (((CharSequence) data.get(0)) instanceof Utf8) { @@ -51,7 +78,11 @@ public void serializeRecord10(IndexedRecord data, Encoder encoder) } @SuppressWarnings("unchecked") +<<<<<<< HEAD public void serializeRecord20(IndexedRecord data, Encoder encoder) +======= + public void serializeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { if (((CharSequence) data.get(0)) instanceof Utf8) { diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java index b518ccb6b..a0d4833fa 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java @@ -5,6 +5,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; import org.apache.avro.util.Utf8; @@ -14,6 +18,7 @@ public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsF { +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -22,6 +27,16 @@ public void serialize(IndexedRecord data, Encoder encoder) @SuppressWarnings("unchecked") public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List recordsArray0 = ((List ) data.get(0)); @@ -34,6 +49,7 @@ public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordColl (encoder).startItem(); IndexedRecord subRecord0 = null; subRecord0 = ((List ) recordsArray0).get(counter0); +<<<<<<< HEAD serializeSubRecord0(subRecord0, (encoder)); } } @@ -44,6 +60,18 @@ public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordColl @SuppressWarnings("unchecked") public void serializeSubRecord0(IndexedRecord data, Encoder encoder) +======= + serializeSubRecord0(subRecord0, (encoder), (customization)); + } + } + (encoder).writeArrayEnd(); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { CharSequence subField0 = ((CharSequence) data.get(0)); @@ -61,10 +89,20 @@ public void serializeSubRecord0(IndexedRecord data, Encoder encoder) } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder) throws IOException { Map recordsMap0 = ((Map ) data.get(1)); +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map recordsMap0 = ((Map ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMap0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((recordsMap0 == null)||recordsMap0 .isEmpty()) { (encoder).setItemCount(0); @@ -75,7 +113,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCo (encoder).writeString(key0); IndexedRecord subRecord1 = null; subRecord1 = ((Map ) recordsMap0).get(key0); +<<<<<<< HEAD serializeSubRecord0(subRecord1, (encoder)); +======= + serializeSubRecord0(subRecord1, (encoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } } (encoder).writeMapEnd(); @@ -101,7 +143,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCo } else { if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { (encoder).writeIndex(1); +<<<<<<< HEAD serializeSubRecord0(((IndexedRecord) union0), (encoder)); +======= + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } } } @@ -112,7 +158,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCo } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map recordsMapUnion0 = ((Map ) data.get(3)); @@ -122,6 +172,12 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCo } else { if (recordsMapUnion0 instanceof Map) { (encoder).writeIndex(1); +<<<<<<< HEAD +======= + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map ) recordsMapUnion0)); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((((Map ) recordsMapUnion0) == null)||((Map ) recordsMapUnion0).isEmpty()) { (encoder).setItemCount(0); @@ -138,7 +194,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCo } else { if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { (encoder).writeIndex(1); +<<<<<<< HEAD serializeSubRecord0(((IndexedRecord) union1), (encoder)); +======= + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } } } diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java index e75b442cd..6c0c14788 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java @@ -5,6 +5,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; import org.apache.avro.util.Utf8; @@ -14,6 +18,7 @@ public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexColle { +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -22,6 +27,16 @@ public void serialize(IndexedRecord data, Encoder encoder) @SuppressWarnings("unchecked") public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List> recordsArrayMap0 = ((List> ) data.get(0)); @@ -34,6 +49,12 @@ public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComp (encoder).startItem(); Map map0 = null; map0 = ((List> ) recordsArrayMap0).get(counter0); +<<<<<<< HEAD +======= + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((map0 == null)||map0 .isEmpty()) { (encoder).setItemCount(0); @@ -50,7 +71,11 @@ public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComp } else { if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { (encoder).writeIndex(1); +<<<<<<< HEAD serializeSubRecord0(((IndexedRecord) union0), (encoder)); +======= + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } } } @@ -59,12 +84,21 @@ public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComp } } (encoder).writeArrayEnd(); +<<<<<<< HEAD serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder)); serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(data, (encoder)); } @SuppressWarnings("unchecked") public void serializeSubRecord0(IndexedRecord data, Encoder encoder) +======= + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { CharSequence subField0 = ((CharSequence) data.get(0)); @@ -82,10 +116,20 @@ public void serializeSubRecord0(IndexedRecord data, Encoder encoder) } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder) throws IOException { Map> recordsMapArray0 = ((Map> ) data.get(1)); +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map> recordsMapArray0 = ((Map> ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMapArray0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((recordsMapArray0 == null)||recordsMapArray0 .isEmpty()) { (encoder).setItemCount(0); @@ -111,7 +155,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCo } else { if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { (encoder).writeIndex(1); +<<<<<<< HEAD serializeSubRecord0(((IndexedRecord) union1), (encoder)); +======= + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } } } @@ -136,6 +184,12 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCo (encoder).startItem(); Map map1 = null; map1 = ((List> )((List> ) recordsArrayMapUnion0)).get(counter2); +<<<<<<< HEAD +======= + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map1); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((map1 == null)||map1 .isEmpty()) { (encoder).setItemCount(0); @@ -152,7 +206,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCo } else { if ((union2 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union2).getSchema().getFullName())) { (encoder).writeIndex(1); +<<<<<<< HEAD serializeSubRecord0(((IndexedRecord) union2), (encoder)); +======= + serializeSubRecord0(((IndexedRecord) union2), (encoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } } } @@ -166,7 +224,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCo } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Map> recordsMapArrayUnion0 = ((Map> ) data.get(3)); @@ -176,6 +238,12 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCo } else { if (recordsMapArrayUnion0 instanceof Map) { (encoder).writeIndex(1); +<<<<<<< HEAD +======= + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map> ) recordsMapArrayUnion0)); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((((Map> ) recordsMapArrayUnion0) == null)||((Map> ) recordsMapArrayUnion0).isEmpty()) { (encoder).setItemCount(0); @@ -201,7 +269,11 @@ private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCo } else { if ((union3 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union3).getSchema().getFullName())) { (encoder).writeIndex(1); +<<<<<<< HEAD serializeSubRecord0(((IndexedRecord) union3), (encoder)); +======= + serializeSubRecord0(((IndexedRecord) union3), (encoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } } } diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java index f2ec5530a..76f7df6a4 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java @@ -3,6 +3,10 @@ import java.io.IOException; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; import org.apache.avro.util.Utf8; @@ -12,6 +16,7 @@ public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_Generi { +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -20,6 +25,16 @@ public void serialize(IndexedRecord data, Encoder encoder) @SuppressWarnings("unchecked") public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { IndexedRecord record0 = ((IndexedRecord) data.get(0)); @@ -29,6 +44,7 @@ public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordFiel } else { if ((record0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) record0).getSchema().getFullName())) { (encoder).writeIndex(1); +<<<<<<< HEAD serializeSubRecord0(((IndexedRecord) record0), (encoder)); } } @@ -37,6 +53,16 @@ public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordFiel @SuppressWarnings("unchecked") public void serializeSubRecord0(IndexedRecord data, Encoder encoder) +======= + serializeSubRecord0(((IndexedRecord) record0), (encoder), (customization)); + } + } + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { CharSequence subField0 = ((CharSequence) data.get(0)); @@ -54,11 +80,19 @@ public void serializeSubRecord0(IndexedRecord data, Encoder encoder) } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder) throws IOException { IndexedRecord record10 = ((IndexedRecord) data.get(1)); serializeSubRecord0(record10, (encoder)); +======= + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + IndexedRecord record10 = ((IndexedRecord) data.get(1)); + serializeSubRecord0(record10, (encoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) CharSequence field0 = ((CharSequence) data.get(2)); if (field0 == null) { (encoder).writeIndex(0); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeEnums_GenericSerializer_957378572.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeEnums_GenericSerializer_957378572.java index f249b3c5d..a885ec20d 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeEnums_GenericSerializer_957378572.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeEnums_GenericSerializer_957378572.java @@ -5,6 +5,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.GenericEnumSymbol; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; @@ -14,6 +18,7 @@ public class FastSerdeEnums_GenericSerializer_957378572 { +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -22,6 +27,16 @@ public void serialize(IndexedRecord data, Encoder encoder) @SuppressWarnings("unchecked") public void serializeFastSerdeEnums0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { int valueToWrite0; @@ -32,11 +47,19 @@ public void serializeFastSerdeEnums0(IndexedRecord data, Encoder encoder) valueToWrite0 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).toString()); } (encoder).writeEnum(valueToWrite0); +<<<<<<< HEAD serialize_FastSerdeEnums0(data, (encoder)); } @SuppressWarnings("unchecked") private void serialize_FastSerdeEnums0(IndexedRecord data, Encoder encoder) +======= + serialize_FastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List arrayOfEnums0 = ((List ) data.get(1)); @@ -67,6 +90,12 @@ private void serialize_FastSerdeEnums0(IndexedRecord data, Encoder encoder) } } Map mapOfEnums0 = ((Map ) data.get(2)); +<<<<<<< HEAD +======= + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfEnums0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((mapOfEnums0 == null)||mapOfEnums0 .isEmpty()) { (encoder).setItemCount(0); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeFixed_GenericSerializer_504108934.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeFixed_GenericSerializer_504108934.java index 23e5625fc..9916ccee2 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeFixed_GenericSerializer_504108934.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeFixed_GenericSerializer_504108934.java @@ -5,6 +5,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.GenericFixed; import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; @@ -14,6 +18,7 @@ public class FastSerdeFixed_GenericSerializer_504108934 { +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -30,6 +35,24 @@ public void serializeFastSerdeFixed0(IndexedRecord data, Encoder encoder) @SuppressWarnings("unchecked") private void serialize_FastSerdeFixed0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List arrayOfFixed0 = ((List ) data.get(1)); @@ -53,6 +76,12 @@ private void serialize_FastSerdeFixed0(IndexedRecord data, Encoder encoder) } } Map mapOfFixed0 = ((Map ) data.get(2)); +<<<<<<< HEAD +======= + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfFixed0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((mapOfFixed0 == null)||mapOfFixed0 .isEmpty()) { (encoder).setItemCount(0); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesDefined_GenericSerializer_229156053.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesDefined_GenericSerializer_229156053.java index 93551504e..3d5480de0 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesDefined_GenericSerializer_229156053.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesDefined_GenericSerializer_229156053.java @@ -6,6 +6,10 @@ import java.time.LocalDate; import java.util.List; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Conversions; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -22,6 +26,7 @@ public class FastSerdeLogicalTypesDefined_GenericSerializer_229156053 private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -30,16 +35,34 @@ public void serialize(IndexedRecord data, Encoder encoder) @SuppressWarnings("unchecked") public void serializeFastSerdeLogicalTypesDefined0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesDefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesDefined0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object convertedValue0 = data.get(0); convertedValue0 = Conversions.convertToRawType(convertedValue0, this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis); (encoder).writeInt(((Integer) convertedValue0)); +<<<<<<< HEAD serialize_FastSerdeLogicalTypesDefined0(data, (encoder)); } @SuppressWarnings("unchecked") private void serialize_FastSerdeLogicalTypesDefined0(IndexedRecord data, Encoder encoder) +======= + serialize_FastSerdeLogicalTypesDefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesDefined0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object convertedValue1 = data.get(1); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesDefined_SpecificSerializer_229156053.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesDefined_SpecificSerializer_229156053.java index e3bb785c0..a556d9fbb 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesDefined_SpecificSerializer_229156053.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesDefined_SpecificSerializer_229156053.java @@ -6,6 +6,10 @@ import java.time.LocalDate; import java.util.List; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined; import org.apache.avro.Conversions; import org.apache.avro.Schema; @@ -22,6 +26,7 @@ public class FastSerdeLogicalTypesDefined_SpecificSerializer_229156053 private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); +<<<<<<< HEAD public void serialize(FastSerdeLogicalTypesDefined data, Encoder encoder) throws IOException { @@ -30,16 +35,34 @@ public void serialize(FastSerdeLogicalTypesDefined data, Encoder encoder) @SuppressWarnings("unchecked") public void serializeFastSerdeLogicalTypesDefined0(FastSerdeLogicalTypesDefined data, Encoder encoder) +======= + public void serialize(FastSerdeLogicalTypesDefined data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesDefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesDefined0(FastSerdeLogicalTypesDefined data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object convertedValue0 = data.get(0); convertedValue0 = Conversions.convertToRawType(convertedValue0, this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis); (encoder).writeInt(((Integer) convertedValue0)); +<<<<<<< HEAD serialize_FastSerdeLogicalTypesDefined0(data, (encoder)); } @SuppressWarnings("unchecked") private void serialize_FastSerdeLogicalTypesDefined0(FastSerdeLogicalTypesDefined data, Encoder encoder) +======= + serialize_FastSerdeLogicalTypesDefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesDefined0(FastSerdeLogicalTypesDefined data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object convertedValue1 = data.get(1); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesTest1_GenericSerializer_1007574890.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesTest1_GenericSerializer_1007574890.java index c0c98c372..d91f3cb40 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesTest1_GenericSerializer_1007574890.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesTest1_GenericSerializer_1007574890.java @@ -12,6 +12,10 @@ import java.util.Map; import com.linkedin.avro.api.PrimitiveIntList; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.Conversions; import org.apache.avro.Schema; import org.apache.avro.generic.IndexedRecord; @@ -39,6 +43,7 @@ public class FastSerdeLogicalTypesTest1_GenericSerializer_1007574890 private final Schema logicalTypeSchema__1515894331 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"time-micros\"}"); private final Schema logicalTypeSchema__250645780 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"local-timestamp-millis\"}"); +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -47,6 +52,16 @@ public void serialize(IndexedRecord data, Encoder encoder) @SuppressWarnings("unchecked") public void serializeFastSerdeLogicalTypesTest10(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesTest10(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesTest10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object unionOfArrayAndMap0 = ((Object) data.get(0)); @@ -79,6 +94,12 @@ public void serializeFastSerdeLogicalTypesTest10(IndexedRecord data, Encoder enc } else { if (unionOfArrayAndMap0 instanceof Map) { (encoder).writeIndex(1); +<<<<<<< HEAD +======= + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map ) unionOfArrayAndMap0)); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((((Map ) unionOfArrayAndMap0) == null)||((Map ) unionOfArrayAndMap0).isEmpty()) { (encoder).setItemCount(0); @@ -95,6 +116,7 @@ public void serializeFastSerdeLogicalTypesTest10(IndexedRecord data, Encoder enc (encoder).writeMapEnd(); } } +<<<<<<< HEAD serialize_FastSerdeLogicalTypesTest10(data, (encoder)); serialize_FastSerdeLogicalTypesTest11(data, (encoder)); serialize_FastSerdeLogicalTypesTest12(data, (encoder)); @@ -108,6 +130,24 @@ private void serialize_FastSerdeLogicalTypesTest10(IndexedRecord data, Encoder e throws IOException { Map mapOfUnionsOfDateAndTimestampMillis0 = ((Map ) data.get(1)); +======= + serialize_FastSerdeLogicalTypesTest10(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest11(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest12(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest13(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest14(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest15(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesTest10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map mapOfUnionsOfDateAndTimestampMillis0 = ((Map ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfUnionsOfDateAndTimestampMillis0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((mapOfUnionsOfDateAndTimestampMillis0 == null)||mapOfUnionsOfDateAndTimestampMillis0 .isEmpty()) { (encoder).setItemCount(0); @@ -135,6 +175,12 @@ private void serialize_FastSerdeLogicalTypesTest10(IndexedRecord data, Encoder e } (encoder).writeMapEnd(); Map timestampMillisMap0 = ((Map ) data.get(2)); +<<<<<<< HEAD +======= + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(timestampMillisMap0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((timestampMillisMap0 == null)||timestampMillisMap0 .isEmpty()) { (encoder).setItemCount(0); @@ -152,7 +198,11 @@ private void serialize_FastSerdeLogicalTypesTest10(IndexedRecord data, Encoder e } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastSerdeLogicalTypesTest11(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastSerdeLogicalTypesTest11(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List nullableArrayOfDates0 = ((List ) data.get(3)); @@ -216,7 +266,11 @@ private void serialize_FastSerdeLogicalTypesTest11(IndexedRecord data, Encoder e } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastSerdeLogicalTypesTest12(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastSerdeLogicalTypesTest12(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object unionOfDecimalOrDate0 = ((Object) data.get(5)); @@ -243,7 +297,11 @@ private void serialize_FastSerdeLogicalTypesTest12(IndexedRecord data, Encoder e } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastSerdeLogicalTypesTest13(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastSerdeLogicalTypesTest13(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object convertedValue13 = data.get(7); @@ -255,7 +313,11 @@ private void serialize_FastSerdeLogicalTypesTest13(IndexedRecord data, Encoder e } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastSerdeLogicalTypesTest14(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastSerdeLogicalTypesTest14(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object convertedValue15 = data.get(9); @@ -267,29 +329,50 @@ private void serialize_FastSerdeLogicalTypesTest14(IndexedRecord data, Encoder e } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastSerdeLogicalTypesTest15(IndexedRecord data, Encoder encoder) +======= + private void serialize_FastSerdeLogicalTypesTest15(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object convertedValue17 = data.get(11); convertedValue17 = Conversions.convertToRawType(convertedValue17, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); (encoder).writeInt(((Integer) convertedValue17)); IndexedRecord nestedLocalTimestampMillis0 = ((IndexedRecord) data.get(12)); +<<<<<<< HEAD serializeLocalTimestampRecord0(nestedLocalTimestampMillis0, (encoder)); } @SuppressWarnings("unchecked") public void serializeLocalTimestampRecord0(IndexedRecord data, Encoder encoder) +======= + serializeLocalTimestampRecord0(nestedLocalTimestampMillis0, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeLocalTimestampRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object convertedValue18 = data.get(0); convertedValue18 = Conversions.convertToRawType(convertedValue18, this.logicalTypeSchema__250645780, this.logicalTypeSchema__250645780 .getLogicalType(), this.conversion_local_timestamp_millis); (encoder).writeLong(((Long) convertedValue18)); +<<<<<<< HEAD serialize_LocalTimestampRecord0(data, (encoder)); serialize_LocalTimestampRecord1(data, (encoder)); } @SuppressWarnings("unchecked") private void serialize_LocalTimestampRecord0(IndexedRecord data, Encoder encoder) +======= + serialize_LocalTimestampRecord0(data, (encoder), (customization)); + serialize_LocalTimestampRecord1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_LocalTimestampRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { LocalDateTime nullableNestedTimestamp0 = ((LocalDateTime) data.get(1)); @@ -324,7 +407,11 @@ private void serialize_LocalTimestampRecord0(IndexedRecord data, Encoder encoder } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_LocalTimestampRecord1(IndexedRecord data, Encoder encoder) +======= + private void serialize_LocalTimestampRecord1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object unionOfDateAndLocalTimestamp0 = ((Object) data.get(3)); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesTest1_SpecificSerializer_1007574890.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesTest1_SpecificSerializer_1007574890.java index 3b701c99a..0436a4477 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesTest1_SpecificSerializer_1007574890.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesTest1_SpecificSerializer_1007574890.java @@ -12,6 +12,10 @@ import java.util.Map; import com.linkedin.avro.api.PrimitiveIntList; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1; import com.linkedin.avro.fastserde.generated.avro.LocalTimestampRecord; import org.apache.avro.Conversions; @@ -40,6 +44,7 @@ public class FastSerdeLogicalTypesTest1_SpecificSerializer_1007574890 private final Schema logicalTypeSchema__1515894331 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"time-micros\"}"); private final Schema logicalTypeSchema__250645780 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"local-timestamp-millis\"}"); +<<<<<<< HEAD public void serialize(FastSerdeLogicalTypesTest1 data, Encoder encoder) throws IOException { @@ -48,6 +53,16 @@ public void serialize(FastSerdeLogicalTypesTest1 data, Encoder encoder) @SuppressWarnings("unchecked") public void serializeFastSerdeLogicalTypesTest10(FastSerdeLogicalTypesTest1 data, Encoder encoder) +======= + public void serialize(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesTest10(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesTest10(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object unionOfArrayAndMap0 = ((Object) data.get(0)); @@ -80,6 +95,12 @@ public void serializeFastSerdeLogicalTypesTest10(FastSerdeLogicalTypesTest1 data } else { if (unionOfArrayAndMap0 instanceof Map) { (encoder).writeIndex(1); +<<<<<<< HEAD +======= + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map ) unionOfArrayAndMap0)); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((((Map ) unionOfArrayAndMap0) == null)||((Map ) unionOfArrayAndMap0).isEmpty()) { (encoder).setItemCount(0); @@ -96,6 +117,7 @@ public void serializeFastSerdeLogicalTypesTest10(FastSerdeLogicalTypesTest1 data (encoder).writeMapEnd(); } } +<<<<<<< HEAD serialize_FastSerdeLogicalTypesTest10(data, (encoder)); serialize_FastSerdeLogicalTypesTest11(data, (encoder)); serialize_FastSerdeLogicalTypesTest12(data, (encoder)); @@ -109,6 +131,24 @@ private void serialize_FastSerdeLogicalTypesTest10(FastSerdeLogicalTypesTest1 da throws IOException { Map mapOfUnionsOfDateAndTimestampMillis0 = ((Map ) data.get(1)); +======= + serialize_FastSerdeLogicalTypesTest10(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest11(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest12(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest13(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest14(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest15(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesTest10(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map mapOfUnionsOfDateAndTimestampMillis0 = ((Map ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfUnionsOfDateAndTimestampMillis0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((mapOfUnionsOfDateAndTimestampMillis0 == null)||mapOfUnionsOfDateAndTimestampMillis0 .isEmpty()) { (encoder).setItemCount(0); @@ -136,6 +176,12 @@ private void serialize_FastSerdeLogicalTypesTest10(FastSerdeLogicalTypesTest1 da } (encoder).writeMapEnd(); Map timestampMillisMap0 = ((Map ) data.get(2)); +<<<<<<< HEAD +======= + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(timestampMillisMap0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((timestampMillisMap0 == null)||timestampMillisMap0 .isEmpty()) { (encoder).setItemCount(0); @@ -153,7 +199,11 @@ private void serialize_FastSerdeLogicalTypesTest10(FastSerdeLogicalTypesTest1 da } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastSerdeLogicalTypesTest11(FastSerdeLogicalTypesTest1 data, Encoder encoder) +======= + private void serialize_FastSerdeLogicalTypesTest11(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List nullableArrayOfDates0 = ((List ) data.get(3)); @@ -217,7 +267,11 @@ private void serialize_FastSerdeLogicalTypesTest11(FastSerdeLogicalTypesTest1 da } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastSerdeLogicalTypesTest12(FastSerdeLogicalTypesTest1 data, Encoder encoder) +======= + private void serialize_FastSerdeLogicalTypesTest12(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object unionOfDecimalOrDate0 = ((Object) data.get(5)); @@ -244,7 +298,11 @@ private void serialize_FastSerdeLogicalTypesTest12(FastSerdeLogicalTypesTest1 da } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastSerdeLogicalTypesTest13(FastSerdeLogicalTypesTest1 data, Encoder encoder) +======= + private void serialize_FastSerdeLogicalTypesTest13(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object convertedValue13 = data.get(7); @@ -256,7 +314,11 @@ private void serialize_FastSerdeLogicalTypesTest13(FastSerdeLogicalTypesTest1 da } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastSerdeLogicalTypesTest14(FastSerdeLogicalTypesTest1 data, Encoder encoder) +======= + private void serialize_FastSerdeLogicalTypesTest14(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object convertedValue15 = data.get(9); @@ -268,29 +330,50 @@ private void serialize_FastSerdeLogicalTypesTest14(FastSerdeLogicalTypesTest1 da } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastSerdeLogicalTypesTest15(FastSerdeLogicalTypesTest1 data, Encoder encoder) +======= + private void serialize_FastSerdeLogicalTypesTest15(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object convertedValue17 = data.get(11); convertedValue17 = Conversions.convertToRawType(convertedValue17, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); (encoder).writeInt(((Integer) convertedValue17)); LocalTimestampRecord nestedLocalTimestampMillis0 = ((LocalTimestampRecord) data.get(12)); +<<<<<<< HEAD serializeLocalTimestampRecord0(nestedLocalTimestampMillis0, (encoder)); } @SuppressWarnings("unchecked") public void serializeLocalTimestampRecord0(LocalTimestampRecord data, Encoder encoder) +======= + serializeLocalTimestampRecord0(nestedLocalTimestampMillis0, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeLocalTimestampRecord0(LocalTimestampRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object convertedValue18 = data.get(0); convertedValue18 = Conversions.convertToRawType(convertedValue18, this.logicalTypeSchema__250645780, this.logicalTypeSchema__250645780 .getLogicalType(), this.conversion_local_timestamp_millis); (encoder).writeLong(((Long) convertedValue18)); +<<<<<<< HEAD serialize_LocalTimestampRecord0(data, (encoder)); serialize_LocalTimestampRecord1(data, (encoder)); } @SuppressWarnings("unchecked") private void serialize_LocalTimestampRecord0(LocalTimestampRecord data, Encoder encoder) +======= + serialize_LocalTimestampRecord0(data, (encoder), (customization)); + serialize_LocalTimestampRecord1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_LocalTimestampRecord0(LocalTimestampRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { LocalDateTime nullableNestedTimestamp0 = ((LocalDateTime) data.get(1)); @@ -325,7 +408,11 @@ private void serialize_LocalTimestampRecord0(LocalTimestampRecord data, Encoder } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_LocalTimestampRecord1(LocalTimestampRecord data, Encoder encoder) +======= + private void serialize_LocalTimestampRecord1(LocalTimestampRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object unionOfDateAndLocalTimestamp0 = ((Object) data.get(3)); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_GenericSerializer_1982763418.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_GenericSerializer_1982763418.java index e78fac629..2e909c8dc 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_GenericSerializer_1982763418.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_GenericSerializer_1982763418.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; @@ -12,6 +16,7 @@ public class FastSerdeLogicalTypesUndefined_GenericSerializer_1982763418 { +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -28,6 +33,24 @@ public void serializeFastSerdeLogicalTypesUndefined0(IndexedRecord data, Encoder @SuppressWarnings("unchecked") private void serialize_FastSerdeLogicalTypesUndefined0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesUndefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesUndefined0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastSerdeLogicalTypesUndefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesUndefined0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(1))); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_SpecificSerializer_1982763418.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_SpecificSerializer_1982763418.java index e4a31721e..1507515cf 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_SpecificSerializer_1982763418.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastSerdeLogicalTypesUndefined_SpecificSerializer_1982763418.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.List; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined; import org.apache.avro.io.Encoder; @@ -12,6 +16,7 @@ public class FastSerdeLogicalTypesUndefined_SpecificSerializer_1982763418 { +<<<<<<< HEAD public void serialize(FastSerdeLogicalTypesUndefined data, Encoder encoder) throws IOException { @@ -28,6 +33,24 @@ public void serializeFastSerdeLogicalTypesUndefined0(FastSerdeLogicalTypesUndefi @SuppressWarnings("unchecked") private void serialize_FastSerdeLogicalTypesUndefined0(FastSerdeLogicalTypesUndefined data, Encoder encoder) +======= + public void serialize(FastSerdeLogicalTypesUndefined data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesUndefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesUndefined0(FastSerdeLogicalTypesUndefined data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastSerdeLogicalTypesUndefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesUndefined0(FastSerdeLogicalTypesUndefined data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeInt(((Integer) data.get(1))); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java index ec3e8bbaa..b33ce74ed 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java @@ -5,6 +5,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; import org.apache.avro.util.Utf8; @@ -14,6 +18,7 @@ public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSeri { +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -22,6 +27,16 @@ public void serialize(IndexedRecord data, Encoder encoder) @SuppressWarnings("unchecked") public void serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { if (((CharSequence) data.get(0)) instanceof Utf8) { @@ -29,12 +44,21 @@ public void serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(In } else { (encoder).writeString(((CharSequence) data.get(0)).toString()); } +<<<<<<< HEAD serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder)); serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest1(data, (encoder)); } @SuppressWarnings("unchecked") private void serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder) +======= + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { CharSequence testUnionString0 = ((CharSequence) data.get(1)); @@ -68,10 +92,20 @@ private void serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0( } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest1(IndexedRecord data, Encoder encoder) throws IOException { Map testStringMap0 = ((Map ) data.get(3)); +======= + private void serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { (encoder).setItemCount(0); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java index 475045cf9..efe8b543a 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java @@ -5,6 +5,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; import org.apache.avro.util.Utf8; @@ -14,6 +18,7 @@ public class FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978 { +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -22,6 +27,16 @@ public void serialize(IndexedRecord data, Encoder encoder) @SuppressWarnings("unchecked") public void serializeFastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { if (((CharSequence) data.get(0)) instanceof Utf8) { @@ -29,12 +44,21 @@ public void serializeFastStringableTest_javaStringPropertyTest0(IndexedRecord da } else { (encoder).writeString(((CharSequence) data.get(0)).toString()); } +<<<<<<< HEAD serialize_FastStringableTest_javaStringPropertyTest0(data, (encoder)); serialize_FastStringableTest_javaStringPropertyTest1(data, (encoder)); } @SuppressWarnings("unchecked") private void serialize_FastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder) +======= + serialize_FastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { CharSequence testUnionString0 = ((CharSequence) data.get(1)); @@ -68,10 +92,20 @@ private void serialize_FastStringableTest_javaStringPropertyTest0(IndexedRecord } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_FastStringableTest_javaStringPropertyTest1(IndexedRecord data, Encoder encoder) throws IOException { Map testStringMap0 = ((Map ) data.get(3)); +======= + private void serialize_FastStringableTest_javaStringPropertyTest1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { (encoder).setItemCount(0); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Map_of_UNION_GenericSerializer_2140000109.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Map_of_UNION_GenericSerializer_2140000109.java index 9aeca0f8a..6aa3df15e 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Map_of_UNION_GenericSerializer_2140000109.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Map_of_UNION_GenericSerializer_2140000109.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.Map; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; import org.apache.avro.util.Utf8; @@ -13,9 +17,18 @@ public class Map_of_UNION_GenericSerializer_2140000109 { +<<<<<<< HEAD public void serialize(Map data, Encoder encoder) throws IOException { +======= + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((data == null)||data.isEmpty()) { (encoder).setItemCount(0); @@ -32,7 +45,11 @@ public void serialize(Map data, Encoder encoder) } else { if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { (encoder).writeIndex(1); +<<<<<<< HEAD serializeRecord0(((IndexedRecord) union0), (encoder)); +======= + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } } } @@ -41,7 +58,11 @@ public void serialize(Map data, Encoder encoder) } @SuppressWarnings("unchecked") +<<<<<<< HEAD public void serializeRecord0(IndexedRecord data, Encoder encoder) +======= + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { CharSequence field0 = ((CharSequence) data.get(0)); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Map_of_record_GenericSerializer_1677529043.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Map_of_record_GenericSerializer_1677529043.java index 6b4925efc..23c59e517 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Map_of_record_GenericSerializer_1677529043.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/Map_of_record_GenericSerializer_1677529043.java @@ -4,6 +4,10 @@ import java.io.IOException; import java.util.Map; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; import org.apache.avro.util.Utf8; @@ -13,9 +17,18 @@ public class Map_of_record_GenericSerializer_1677529043 { +<<<<<<< HEAD public void serialize(Map data, Encoder encoder) throws IOException { +======= + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((data == null)||data.isEmpty()) { (encoder).setItemCount(0); @@ -26,14 +39,22 @@ public void serialize(Map data, Encoder encoder) (encoder).writeString(key0); IndexedRecord record0 = null; record0 = ((Map ) data).get(key0); +<<<<<<< HEAD serializeRecord0(record0, (encoder)); +======= + serializeRecord0(record0, (encoder), (customization)); +>>>>>>> 6f03f254 (Added generated test classes temporarily) } } (encoder).writeMapEnd(); } @SuppressWarnings("unchecked") +<<<<<<< HEAD public void serializeRecord0(IndexedRecord data, Encoder encoder) +======= + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { CharSequence field0 = ((CharSequence) data.get(0)); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/StringableRecord_SpecificSerializer_842267318.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/StringableRecord_SpecificSerializer_842267318.java index af5c14728..240a87204 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/StringableRecord_SpecificSerializer_842267318.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/StringableRecord_SpecificSerializer_842267318.java @@ -10,6 +10,10 @@ import java.util.List; import java.util.Map; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord; import com.linkedin.avro.fastserde.generated.avro.StringableRecord; import com.linkedin.avro.fastserde.generated.avro.StringableSubRecord; @@ -21,6 +25,7 @@ public class StringableRecord_SpecificSerializer_842267318 { +<<<<<<< HEAD public void serialize(StringableRecord data, Encoder encoder) throws IOException { @@ -41,6 +46,28 @@ public void serializeStringableRecord0(StringableRecord data, Encoder encoder) @SuppressWarnings("unchecked") private void serialize_StringableRecord0(StringableRecord data, Encoder encoder) +======= + public void serialize(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeStringableRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((BigInteger) data.get(0)).toString()); + serialize_StringableRecord0(data, (encoder), (customization)); + serialize_StringableRecord1(data, (encoder), (customization)); + serialize_StringableRecord2(data, (encoder), (customization)); + serialize_StringableRecord3(data, (encoder), (customization)); + serialize_StringableRecord4(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeString(((BigDecimal) data.get(1)).toString()); @@ -48,7 +75,11 @@ private void serialize_StringableRecord0(StringableRecord data, Encoder encoder) } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_StringableRecord1(StringableRecord data, Encoder encoder) +======= + private void serialize_StringableRecord1(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { (encoder).writeString(((URL) data.get(3)).toString()); @@ -56,7 +87,11 @@ private void serialize_StringableRecord1(StringableRecord data, Encoder encoder) } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_StringableRecord2(StringableRecord data, Encoder encoder) +======= + private void serialize_StringableRecord2(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List urlArray0 = ((List ) data.get(5)); @@ -72,6 +107,12 @@ private void serialize_StringableRecord2(StringableRecord data, Encoder encoder) } (encoder).writeArrayEnd(); Map urlMap0 = ((Map ) data.get(6)); +<<<<<<< HEAD +======= + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(urlMap0); + } +>>>>>>> 6f03f254 (Added generated test classes temporarily) (encoder).writeMapStart(); if ((urlMap0 == null)||urlMap0 .isEmpty()) { (encoder).setItemCount(0); @@ -88,6 +129,7 @@ private void serialize_StringableRecord2(StringableRecord data, Encoder encoder) } @SuppressWarnings("unchecked") +<<<<<<< HEAD private void serialize_StringableRecord3(StringableRecord data, Encoder encoder) throws IOException { @@ -107,6 +149,27 @@ public void serializeStringableSubRecord0(StringableSubRecord data, Encoder enco @SuppressWarnings("unchecked") private void serialize_StringableSubRecord0(StringableSubRecord data, Encoder encoder) +======= + private void serialize_StringableRecord3(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord0 = ((StringableSubRecord) data.get(7)); + serializeStringableSubRecord0(subRecord0, (encoder), (customization)); + AnotherSubRecord subRecordWithSubRecord0 = ((AnotherSubRecord) data.get(8)); + serializeAnotherSubRecord0(subRecordWithSubRecord0, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((URI) data.get(0)).toString()); + serialize_StringableSubRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { Object nullStringIntUnion0 = ((Object) data.get(1)); @@ -131,6 +194,7 @@ private void serialize_StringableSubRecord0(StringableSubRecord data, Encoder en } @SuppressWarnings("unchecked") +<<<<<<< HEAD public void serializeAnotherSubRecord0(AnotherSubRecord data, Encoder encoder) throws IOException { @@ -140,6 +204,17 @@ public void serializeAnotherSubRecord0(AnotherSubRecord data, Encoder encoder) @SuppressWarnings("unchecked") private void serialize_StringableRecord4(StringableRecord data, Encoder encoder) +======= + public void serializeAnotherSubRecord0(AnotherSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord1 = ((StringableSubRecord) data.get(0)); + serializeStringableSubRecord0(subRecord1, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord4(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { String stringUnion0 = ((String) data.get(9)); diff --git a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/TestArrayOfFloats_GenericSerializer_1408566797.java b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/TestArrayOfFloats_GenericSerializer_1408566797.java index 90b8bcd9d..dc4e065d1 100644 --- a/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/TestArrayOfFloats_GenericSerializer_1408566797.java +++ b/fastserde/avro-fastserde-tests111/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_11/TestArrayOfFloats_GenericSerializer_1408566797.java @@ -6,6 +6,10 @@ import com.linkedin.avro.api.PrimitiveFloatList; import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; import com.linkedin.avro.fastserde.FastSerializer; +<<<<<<< HEAD +======= +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +>>>>>>> 6f03f254 (Added generated test classes temporarily) import org.apache.avro.generic.IndexedRecord; import org.apache.avro.io.Encoder; @@ -14,6 +18,7 @@ public class TestArrayOfFloats_GenericSerializer_1408566797 { +<<<<<<< HEAD public void serialize(IndexedRecord data, Encoder encoder) throws IOException { @@ -22,6 +27,16 @@ public void serialize(IndexedRecord data, Encoder encoder) @SuppressWarnings("unchecked") public void serializeTestArrayOfFloats0(IndexedRecord data, Encoder encoder) +======= + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeTestArrayOfFloats0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeTestArrayOfFloats0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) +>>>>>>> 6f03f254 (Added generated test classes temporarily) throws IOException { List array_of_float0 = ((List ) data.get(0)); diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/Array_of_BOOLEAN_GenericDeserializer_869749973_869749973.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/Array_of_BOOLEAN_GenericDeserializer_869749973_869749973.java new file mode 100644 index 000000000..2051ec56a --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/Array_of_BOOLEAN_GenericDeserializer_869749973_869749973.java @@ -0,0 +1,43 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class Array_of_BOOLEAN_GenericDeserializer_869749973_869749973 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Array_of_BOOLEAN_GenericDeserializer_869749973_869749973(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveBooleanList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveBooleanList) { + array0 = ((PrimitiveBooleanList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveBooleanArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_DOUBLE_GenericDeserializer_18760307_18760307(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveDoubleList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveDoubleList) { + array0 = ((PrimitiveDoubleList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveDoubleArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_FLOAT_GenericDeserializer_1012670397_1012670397(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveFloatList array0 = null; + array0 = ((PrimitiveFloatList) BufferBackedPrimitiveFloatList.readPrimitiveFloatArray((reuse), (decoder))); + return array0; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/Array_of_INT_GenericDeserializer_1012089072_1012089072.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/Array_of_INT_GenericDeserializer_1012089072_1012089072.java new file mode 100644 index 000000000..6a3c60063 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/Array_of_INT_GenericDeserializer_1012089072_1012089072.java @@ -0,0 +1,43 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class Array_of_INT_GenericDeserializer_1012089072_1012089072 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Array_of_INT_GenericDeserializer_1012089072_1012089072(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveIntList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveIntList) { + array0 = ((PrimitiveIntList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_LONG_GenericDeserializer_325099267_325099267(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveLongList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveLongList) { + array0 = ((PrimitiveLongList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveLongArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_TestRecord_SpecificDeserializer_1347912411_1347912411(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema arrayArrayElemSchema0; + private final Schema arrayElemOptionSchema0; + private final Schema field0; + + public Array_of_UNION_GenericDeserializer_777827233_777827233(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArrayElemSchema0 = readerSchema.getElementType(); + this.arrayElemOptionSchema0 = arrayArrayElemSchema0 .getTypes().get(1); + this.field0 = arrayElemOptionSchema0 .getField("field").schema(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_UNION_SpecificDeserializer_1813090821_1813090821(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex15 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex17)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex21 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex21)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex23 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex23)); + } + } + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex25 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex25 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex25 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex25)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema unionOptionArrayElemSchema0; + + public Array_of_record_GenericDeserializer_1606337179_2018567528(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOptionArrayElemSchema0 = readerSchema.getElementType(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":{\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}}"); + } else { + if (unionIndex0 == 1) { + List unionOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + unionOption0 = ((List)(reuse)); + unionOption0 .clear(); + } else { + unionOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + private final Schema arrayArrayElemSchema0; + private final Schema field0; + + public Array_of_record_GenericDeserializer_477614132_477614132(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArrayElemSchema0 = readerSchema.getElementType(); + this.field0 = arrayArrayElemSchema0 .getField("field").schema(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema f00; + private final Schema f10; + private final Schema f20; + private final Schema f30; + private final Schema f40; + private final Schema f50; + private final Schema f60; + private final Schema f70; + private final Schema f80; + private final Schema f90; + private final Schema f100; + private final Schema f110; + private final Schema f120; + private final Schema f130; + private final Schema f140; + private final Schema f150; + private final Schema f160; + private final Schema f170; + private final Schema f180; + private final Schema f190; + private final Schema f200; + private final Schema f210; + private final Schema f220; + private final Schema f230; + private final Schema f240; + private final Schema f250; + private final Schema f260; + private final Schema f270; + private final Schema f280; + private final Schema f290; + private final Schema f300; + private final Schema f310; + private final Schema f320; + private final Schema f330; + private final Schema f340; + private final Schema f350; + private final Schema f360; + private final Schema f370; + private final Schema f380; + private final Schema f390; + private final Schema f400; + private final Schema f410; + private final Schema f420; + private final Schema f430; + private final Schema f440; + private final Schema f450; + private final Schema f460; + private final Schema f470; + private final Schema f480; + private final Schema f490; + private final Schema f500; + private final Schema f510; + private final Schema f520; + private final Schema f530; + private final Schema f540; + private final Schema f550; + private final Schema f560; + private final Schema f570; + private final Schema f580; + private final Schema f590; + private final Schema f600; + private final Schema f610; + private final Schema f620; + private final Schema f630; + private final Schema f640; + private final Schema f650; + private final Schema f660; + private final Schema f670; + private final Schema f680; + private final Schema f690; + private final Schema f700; + private final Schema f710; + private final Schema f720; + private final Schema f730; + private final Schema f740; + private final Schema f750; + private final Schema f760; + private final Schema f770; + private final Schema f780; + private final Schema f790; + private final Schema f800; + private final Schema f810; + private final Schema f820; + private final Schema f830; + private final Schema f840; + private final Schema f850; + private final Schema f860; + private final Schema f870; + private final Schema f880; + private final Schema f890; + private final Schema f900; + private final Schema f910; + private final Schema f920; + private final Schema f930; + private final Schema f940; + private final Schema f950; + private final Schema f960; + private final Schema f970; + private final Schema f980; + private final Schema f990; + private final Schema f1000; + private final Schema f1010; + private final Schema f1020; + private final Schema f1030; + private final Schema f1040; + private final Schema f1050; + private final Schema f1060; + private final Schema f1070; + private final Schema f1080; + private final Schema f1090; + private final Schema f1100; + private final Schema f1110; + private final Schema f1120; + private final Schema f1130; + private final Schema f1140; + private final Schema f1150; + private final Schema f1160; + private final Schema f1170; + private final Schema f1180; + private final Schema f1190; + private final Schema f1200; + private final Schema f1210; + private final Schema f1220; + private final Schema f1230; + private final Schema f1240; + private final Schema f1250; + private final Schema f1260; + private final Schema f1270; + private final Schema f1280; + private final Schema f1290; + private final Schema f1300; + private final Schema f1310; + private final Schema f1320; + private final Schema f1330; + private final Schema f1340; + private final Schema f1350; + private final Schema f1360; + private final Schema f1370; + private final Schema f1380; + private final Schema f1390; + private final Schema f1400; + private final Schema f1410; + private final Schema f1420; + private final Schema f1430; + private final Schema f1440; + private final Schema f1450; + private final Schema f1460; + private final Schema f1470; + private final Schema f1480; + private final Schema f1490; + private final Schema f1500; + private final Schema f1510; + private final Schema f1520; + private final Schema f1530; + private final Schema f1540; + private final Schema f1550; + private final Schema f1560; + private final Schema f1570; + private final Schema f1580; + private final Schema f1590; + private final Schema f1600; + private final Schema f1610; + private final Schema f1620; + private final Schema f1630; + private final Schema f1640; + private final Schema f1650; + private final Schema f1660; + private final Schema f1670; + private final Schema f1680; + private final Schema f1690; + private final Schema f1700; + private final Schema f1710; + private final Schema f1720; + private final Schema f1730; + private final Schema f1740; + private final Schema f1750; + private final Schema f1760; + private final Schema f1770; + private final Schema f1780; + private final Schema f1790; + private final Schema f1800; + private final Schema f1810; + private final Schema f1820; + private final Schema f1830; + private final Schema f1840; + private final Schema f1850; + private final Schema f1860; + private final Schema f1870; + private final Schema f1880; + private final Schema f1890; + private final Schema f1900; + private final Schema f1910; + private final Schema f1920; + private final Schema f1930; + private final Schema f1940; + private final Schema f1950; + private final Schema f1960; + private final Schema f1970; + private final Schema f1980; + private final Schema f1990; + private final Schema f2000; + private final Schema f2010; + private final Schema f2020; + private final Schema f2030; + private final Schema f2040; + private final Schema f2050; + private final Schema f2060; + private final Schema f2070; + private final Schema f2080; + private final Schema f2090; + private final Schema f2100; + private final Schema f2110; + private final Schema f2120; + private final Schema f2130; + private final Schema f2140; + private final Schema f2150; + private final Schema f2160; + private final Schema f2170; + private final Schema f2180; + private final Schema f2190; + private final Schema f2200; + private final Schema f2210; + private final Schema f2220; + private final Schema f2230; + private final Schema f2240; + private final Schema f2250; + private final Schema f2260; + private final Schema f2270; + private final Schema f2280; + private final Schema f2290; + private final Schema f2300; + private final Schema f2310; + private final Schema f2320; + private final Schema f2330; + private final Schema f2340; + private final Schema f2350; + private final Schema f2360; + private final Schema f2370; + private final Schema f2380; + private final Schema f2390; + private final Schema f2400; + private final Schema f2410; + private final Schema f2420; + private final Schema f2430; + private final Schema f2440; + private final Schema f2450; + private final Schema f2460; + private final Schema f2470; + private final Schema f2480; + private final Schema f2490; + private final Schema f2500; + private final Schema f2510; + private final Schema f2520; + private final Schema f2530; + private final Schema f2540; + private final Schema f2550; + private final Schema f2560; + private final Schema f2570; + private final Schema f2580; + private final Schema f2590; + private final Schema f2600; + private final Schema f2610; + private final Schema f2620; + private final Schema f2630; + private final Schema f2640; + private final Schema f2650; + private final Schema f2660; + private final Schema f2670; + private final Schema f2680; + private final Schema f2690; + private final Schema f2700; + private final Schema f2710; + private final Schema f2720; + private final Schema f2730; + private final Schema f2740; + private final Schema f2750; + private final Schema f2760; + private final Schema f2770; + private final Schema f2780; + private final Schema f2790; + private final Schema f2800; + private final Schema f2810; + private final Schema f2820; + private final Schema f2830; + private final Schema f2840; + private final Schema f2850; + private final Schema f2860; + private final Schema f2870; + private final Schema f2880; + private final Schema f2890; + private final Schema f2900; + private final Schema f2910; + private final Schema f2920; + private final Schema f2930; + private final Schema f2940; + private final Schema f2950; + private final Schema f2960; + private final Schema f2970; + private final Schema f2980; + private final Schema f2990; + private final Schema f3000; + private final Schema f3010; + private final Schema f3020; + private final Schema f3030; + private final Schema f3040; + private final Schema f3050; + private final Schema f3060; + private final Schema f3070; + private final Schema f3080; + private final Schema f3090; + private final Schema f3100; + private final Schema f3110; + private final Schema f3120; + private final Schema f3130; + private final Schema f3140; + private final Schema f3150; + private final Schema f3160; + private final Schema f3170; + private final Schema f3180; + private final Schema f3190; + private final Schema f3200; + private final Schema f3210; + private final Schema f3220; + private final Schema f3230; + private final Schema f3240; + private final Schema f3250; + private final Schema f3260; + private final Schema f3270; + private final Schema f3280; + private final Schema f3290; + private final Schema f3300; + private final Schema f3310; + private final Schema f3320; + private final Schema f3330; + private final Schema f3340; + private final Schema f3350; + private final Schema f3360; + private final Schema f3370; + private final Schema f3380; + private final Schema f3390; + private final Schema f3400; + private final Schema f3410; + private final Schema f3420; + private final Schema f3430; + private final Schema f3440; + private final Schema f3450; + private final Schema f3460; + private final Schema f3470; + private final Schema f3480; + private final Schema f3490; + private final Schema f3500; + private final Schema f3510; + private final Schema f3520; + private final Schema f3530; + private final Schema f3540; + private final Schema f3550; + private final Schema f3560; + private final Schema f3570; + private final Schema f3580; + private final Schema f3590; + private final Schema f3600; + private final Schema f3610; + private final Schema f3620; + private final Schema f3630; + private final Schema f3640; + private final Schema f3650; + private final Schema f3660; + private final Schema f3670; + private final Schema f3680; + private final Schema f3690; + private final Schema f3700; + private final Schema f3710; + private final Schema f3720; + private final Schema f3730; + private final Schema f3740; + private final Schema f3750; + private final Schema f3760; + private final Schema f3770; + private final Schema f3780; + private final Schema f3790; + private final Schema f3800; + private final Schema f3810; + private final Schema f3820; + private final Schema f3830; + private final Schema f3840; + private final Schema f3850; + private final Schema f3860; + private final Schema f3870; + private final Schema f3880; + private final Schema f3890; + private final Schema f3900; + private final Schema f3910; + private final Schema f3920; + private final Schema f3930; + private final Schema f3940; + private final Schema f3950; + private final Schema f3960; + private final Schema f3970; + private final Schema f3980; + private final Schema f3990; + private final Schema f4000; + private final Schema f4010; + private final Schema f4020; + private final Schema f4030; + private final Schema f4040; + private final Schema f4050; + private final Schema f4060; + private final Schema f4070; + private final Schema f4080; + private final Schema f4090; + private final Schema f4100; + private final Schema f4110; + private final Schema f4120; + private final Schema f4130; + private final Schema f4140; + private final Schema f4150; + private final Schema f4160; + private final Schema f4170; + private final Schema f4180; + private final Schema f4190; + private final Schema f4200; + private final Schema f4210; + private final Schema f4220; + private final Schema f4230; + private final Schema f4240; + private final Schema f4250; + private final Schema f4260; + private final Schema f4270; + private final Schema f4280; + private final Schema f4290; + private final Schema f4300; + private final Schema f4310; + private final Schema f4320; + private final Schema f4330; + private final Schema f4340; + private final Schema f4350; + private final Schema f4360; + private final Schema f4370; + private final Schema f4380; + private final Schema f4390; + private final Schema f4400; + private final Schema f4410; + private final Schema f4420; + private final Schema f4430; + private final Schema f4440; + private final Schema f4450; + private final Schema f4460; + private final Schema f4470; + private final Schema f4480; + private final Schema f4490; + private final Schema f4500; + private final Schema f4510; + private final Schema f4520; + private final Schema f4530; + private final Schema f4540; + private final Schema f4550; + private final Schema f4560; + private final Schema f4570; + private final Schema f4580; + private final Schema f4590; + private final Schema f4600; + private final Schema f4610; + private final Schema f4620; + private final Schema f4630; + private final Schema f4640; + private final Schema f4650; + private final Schema f4660; + private final Schema f4670; + private final Schema f4680; + private final Schema f4690; + private final Schema f4700; + private final Schema f4710; + private final Schema f4720; + private final Schema f4730; + private final Schema f4740; + private final Schema f4750; + private final Schema f4760; + private final Schema f4770; + private final Schema f4780; + private final Schema f4790; + private final Schema f4800; + private final Schema f4810; + private final Schema f4820; + private final Schema f4830; + private final Schema f4840; + private final Schema f4850; + private final Schema f4860; + private final Schema f4870; + private final Schema f4880; + private final Schema f4890; + private final Schema f4900; + private final Schema f4910; + private final Schema f4920; + private final Schema f4930; + private final Schema f4940; + private final Schema f4950; + private final Schema f4960; + private final Schema f4970; + private final Schema f4980; + private final Schema f4990; + private final Schema f5000; + private final Schema f5010; + private final Schema f5020; + private final Schema f5030; + private final Schema f5040; + private final Schema f5050; + private final Schema f5060; + private final Schema f5070; + private final Schema f5080; + private final Schema f5090; + private final Schema f5100; + private final Schema f5110; + private final Schema f5120; + private final Schema f5130; + private final Schema f5140; + private final Schema f5150; + private final Schema f5160; + private final Schema f5170; + private final Schema f5180; + private final Schema f5190; + private final Schema f5200; + private final Schema f5210; + private final Schema f5220; + private final Schema f5230; + private final Schema f5240; + private final Schema f5250; + private final Schema f5260; + private final Schema f5270; + private final Schema f5280; + private final Schema f5290; + private final Schema f5300; + private final Schema f5310; + private final Schema f5320; + private final Schema f5330; + private final Schema f5340; + private final Schema f5350; + private final Schema f5360; + private final Schema f5370; + private final Schema f5380; + private final Schema f5390; + private final Schema f5400; + private final Schema f5410; + private final Schema f5420; + private final Schema f5430; + private final Schema f5440; + private final Schema f5450; + private final Schema f5460; + private final Schema f5470; + private final Schema f5480; + private final Schema f5490; + private final Schema f5500; + private final Schema f5510; + private final Schema f5520; + private final Schema f5530; + private final Schema f5540; + private final Schema f5550; + private final Schema f5560; + private final Schema f5570; + private final Schema f5580; + private final Schema f5590; + private final Schema f5600; + private final Schema f5610; + private final Schema f5620; + private final Schema f5630; + private final Schema f5640; + private final Schema f5650; + private final Schema f5660; + private final Schema f5670; + private final Schema f5680; + private final Schema f5690; + private final Schema f5700; + private final Schema f5710; + private final Schema f5720; + private final Schema f5730; + private final Schema f5740; + private final Schema f5750; + private final Schema f5760; + private final Schema f5770; + private final Schema f5780; + private final Schema f5790; + private final Schema f5800; + private final Schema f5810; + private final Schema f5820; + private final Schema f5830; + private final Schema f5840; + private final Schema f5850; + private final Schema f5860; + private final Schema f5870; + private final Schema f5880; + private final Schema f5890; + private final Schema f5900; + private final Schema f5910; + private final Schema f5920; + private final Schema f5930; + private final Schema f5940; + private final Schema f5950; + private final Schema f5960; + private final Schema f5970; + private final Schema f5980; + private final Schema f5990; + private final Schema f6000; + private final Schema f6010; + private final Schema f6020; + private final Schema f6030; + private final Schema f6040; + private final Schema f6050; + private final Schema f6060; + private final Schema f6070; + private final Schema f6080; + private final Schema f6090; + private final Schema f6100; + private final Schema f6110; + private final Schema f6120; + private final Schema f6130; + private final Schema f6140; + private final Schema f6150; + private final Schema f6160; + private final Schema f6170; + private final Schema f6180; + private final Schema f6190; + private final Schema f6200; + private final Schema f6210; + private final Schema f6220; + private final Schema f6230; + private final Schema f6240; + private final Schema f6250; + private final Schema f6260; + private final Schema f6270; + private final Schema f6280; + private final Schema f6290; + private final Schema f6300; + private final Schema f6310; + private final Schema f6320; + private final Schema f6330; + private final Schema f6340; + private final Schema f6350; + private final Schema f6360; + private final Schema f6370; + private final Schema f6380; + private final Schema f6390; + private final Schema f6400; + private final Schema f6410; + private final Schema f6420; + private final Schema f6430; + private final Schema f6440; + private final Schema f6450; + private final Schema f6460; + private final Schema f6470; + private final Schema f6480; + private final Schema f6490; + private final Schema f6500; + private final Schema f6510; + private final Schema f6520; + private final Schema f6530; + private final Schema f6540; + private final Schema f6550; + private final Schema f6560; + private final Schema f6570; + private final Schema f6580; + private final Schema f6590; + private final Schema f6600; + private final Schema f6610; + private final Schema f6620; + private final Schema f6630; + private final Schema f6640; + private final Schema f6650; + private final Schema f6660; + private final Schema f6670; + private final Schema f6680; + private final Schema f6690; + private final Schema f6700; + private final Schema f6710; + private final Schema f6720; + private final Schema f6730; + private final Schema f6740; + private final Schema f6750; + private final Schema f6760; + private final Schema f6770; + private final Schema f6780; + private final Schema f6790; + private final Schema f6800; + private final Schema f6810; + private final Schema f6820; + private final Schema f6830; + private final Schema f6840; + private final Schema f6850; + private final Schema f6860; + private final Schema f6870; + private final Schema f6880; + private final Schema f6890; + private final Schema f6900; + private final Schema f6910; + private final Schema f6920; + private final Schema f6930; + private final Schema f6940; + private final Schema f6950; + private final Schema f6960; + private final Schema f6970; + private final Schema f6980; + private final Schema f6990; + private final Schema f7000; + private final Schema f7010; + private final Schema f7020; + private final Schema f7030; + private final Schema f7040; + private final Schema f7050; + private final Schema f7060; + private final Schema f7070; + private final Schema f7080; + private final Schema f7090; + private final Schema f7100; + private final Schema f7110; + private final Schema f7120; + private final Schema f7130; + private final Schema f7140; + private final Schema f7150; + private final Schema f7160; + private final Schema f7170; + private final Schema f7180; + private final Schema f7190; + private final Schema f7200; + private final Schema f7210; + private final Schema f7220; + private final Schema f7230; + private final Schema f7240; + private final Schema f7250; + private final Schema f7260; + private final Schema f7270; + private final Schema f7280; + private final Schema f7290; + private final Schema f7300; + private final Schema f7310; + private final Schema f7320; + private final Schema f7330; + private final Schema f7340; + private final Schema f7350; + private final Schema f7360; + private final Schema f7370; + private final Schema f7380; + private final Schema f7390; + private final Schema f7400; + private final Schema f7410; + private final Schema f7420; + private final Schema f7430; + private final Schema f7440; + private final Schema f7450; + private final Schema f7460; + private final Schema f7470; + private final Schema f7480; + private final Schema f7490; + private final Schema f7500; + private final Schema f7510; + private final Schema f7520; + private final Schema f7530; + private final Schema f7540; + private final Schema f7550; + private final Schema f7560; + private final Schema f7570; + private final Schema f7580; + private final Schema f7590; + private final Schema f7600; + private final Schema f7610; + private final Schema f7620; + private final Schema f7630; + private final Schema f7640; + private final Schema f7650; + private final Schema f7660; + private final Schema f7670; + private final Schema f7680; + private final Schema f7690; + private final Schema f7700; + private final Schema f7710; + private final Schema f7720; + private final Schema f7730; + private final Schema f7740; + private final Schema f7750; + private final Schema f7760; + private final Schema f7770; + private final Schema f7780; + private final Schema f7790; + private final Schema f7800; + private final Schema f7810; + private final Schema f7820; + private final Schema f7830; + private final Schema f7840; + private final Schema f7850; + private final Schema f7860; + private final Schema f7870; + private final Schema f7880; + private final Schema f7890; + private final Schema f7900; + private final Schema f7910; + private final Schema f7920; + private final Schema f7930; + private final Schema f7940; + private final Schema f7950; + private final Schema f7960; + private final Schema f7970; + private final Schema f7980; + private final Schema f7990; + private final Schema f8000; + private final Schema f8010; + private final Schema f8020; + private final Schema f8030; + private final Schema f8040; + private final Schema f8050; + private final Schema f8060; + private final Schema f8070; + private final Schema f8080; + private final Schema f8090; + private final Schema f8100; + private final Schema f8110; + private final Schema f8120; + private final Schema f8130; + private final Schema f8140; + private final Schema f8150; + private final Schema f8160; + private final Schema f8170; + private final Schema f8180; + private final Schema f8190; + private final Schema f8200; + private final Schema f8210; + private final Schema f8220; + private final Schema f8230; + private final Schema f8240; + private final Schema f8250; + private final Schema f8260; + private final Schema f8270; + private final Schema f8280; + private final Schema f8290; + private final Schema f8300; + private final Schema f8310; + private final Schema f8320; + private final Schema f8330; + private final Schema f8340; + private final Schema f8350; + private final Schema f8360; + private final Schema f8370; + private final Schema f8380; + private final Schema f8390; + private final Schema f8400; + private final Schema f8410; + private final Schema f8420; + private final Schema f8430; + private final Schema f8440; + private final Schema f8450; + private final Schema f8460; + private final Schema f8470; + private final Schema f8480; + private final Schema f8490; + private final Schema f8500; + private final Schema f8510; + private final Schema f8520; + private final Schema f8530; + private final Schema f8540; + private final Schema f8550; + private final Schema f8560; + private final Schema f8570; + private final Schema f8580; + private final Schema f8590; + private final Schema f8600; + private final Schema f8610; + private final Schema f8620; + private final Schema f8630; + private final Schema f8640; + private final Schema f8650; + private final Schema f8660; + private final Schema f8670; + private final Schema f8680; + private final Schema f8690; + private final Schema f8700; + private final Schema f8710; + private final Schema f8720; + private final Schema f8730; + private final Schema f8740; + private final Schema f8750; + private final Schema f8760; + private final Schema f8770; + private final Schema f8780; + private final Schema f8790; + private final Schema f8800; + private final Schema f8810; + private final Schema f8820; + private final Schema f8830; + private final Schema f8840; + private final Schema f8850; + private final Schema f8860; + private final Schema f8870; + private final Schema f8880; + private final Schema f8890; + private final Schema f8900; + private final Schema f8910; + private final Schema f8920; + private final Schema f8930; + private final Schema f8940; + private final Schema f8950; + private final Schema f8960; + private final Schema f8970; + private final Schema f8980; + private final Schema f8990; + private final Schema f9000; + private final Schema f9010; + private final Schema f9020; + private final Schema f9030; + private final Schema f9040; + private final Schema f9050; + private final Schema f9060; + private final Schema f9070; + private final Schema f9080; + private final Schema f9090; + private final Schema f9100; + private final Schema f9110; + private final Schema f9120; + private final Schema f9130; + private final Schema f9140; + private final Schema f9150; + private final Schema f9160; + private final Schema f9170; + private final Schema f9180; + private final Schema f9190; + private final Schema f9200; + private final Schema f9210; + private final Schema f9220; + private final Schema f9230; + private final Schema f9240; + private final Schema f9250; + private final Schema f9260; + private final Schema f9270; + private final Schema f9280; + private final Schema f9290; + private final Schema f9300; + private final Schema f9310; + private final Schema f9320; + private final Schema f9330; + private final Schema f9340; + private final Schema f9350; + private final Schema f9360; + private final Schema f9370; + private final Schema f9380; + private final Schema f9390; + private final Schema f9400; + private final Schema f9410; + private final Schema f9420; + private final Schema f9430; + private final Schema f9440; + private final Schema f9450; + private final Schema f9460; + private final Schema f9470; + private final Schema f9480; + private final Schema f9490; + private final Schema f9500; + private final Schema f9510; + private final Schema f9520; + private final Schema f9530; + private final Schema f9540; + private final Schema f9550; + private final Schema f9560; + private final Schema f9570; + private final Schema f9580; + private final Schema f9590; + private final Schema f9600; + private final Schema f9610; + private final Schema f9620; + private final Schema f9630; + private final Schema f9640; + private final Schema f9650; + private final Schema f9660; + private final Schema f9670; + private final Schema f9680; + private final Schema f9690; + private final Schema f9700; + private final Schema f9710; + private final Schema f9720; + private final Schema f9730; + private final Schema f9740; + private final Schema f9750; + private final Schema f9760; + private final Schema f9770; + private final Schema f9780; + private final Schema f9790; + private final Schema f9800; + private final Schema f9810; + private final Schema f9820; + private final Schema f9830; + private final Schema f9840; + private final Schema f9850; + private final Schema f9860; + private final Schema f9870; + private final Schema f9880; + private final Schema f9890; + private final Schema f9900; + private final Schema f9910; + private final Schema f9920; + private final Schema f9930; + private final Schema f9940; + private final Schema f9950; + private final Schema f9960; + private final Schema f9970; + private final Schema f9980; + private final Schema f9990; + + public FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema_GenericDeserializer_836892732_836892732(Schema readerSchema) { + this.readerSchema = readerSchema; + this.f00 = readerSchema.getField("F0").schema(); + this.f10 = readerSchema.getField("F1").schema(); + this.f20 = readerSchema.getField("F2").schema(); + this.f30 = readerSchema.getField("F3").schema(); + this.f40 = readerSchema.getField("F4").schema(); + this.f50 = readerSchema.getField("F5").schema(); + this.f60 = readerSchema.getField("F6").schema(); + this.f70 = readerSchema.getField("F7").schema(); + this.f80 = readerSchema.getField("F8").schema(); + this.f90 = readerSchema.getField("F9").schema(); + this.f100 = readerSchema.getField("F10").schema(); + this.f110 = readerSchema.getField("F11").schema(); + this.f120 = readerSchema.getField("F12").schema(); + this.f130 = readerSchema.getField("F13").schema(); + this.f140 = readerSchema.getField("F14").schema(); + this.f150 = readerSchema.getField("F15").schema(); + this.f160 = readerSchema.getField("F16").schema(); + this.f170 = readerSchema.getField("F17").schema(); + this.f180 = readerSchema.getField("F18").schema(); + this.f190 = readerSchema.getField("F19").schema(); + this.f200 = readerSchema.getField("F20").schema(); + this.f210 = readerSchema.getField("F21").schema(); + this.f220 = readerSchema.getField("F22").schema(); + this.f230 = readerSchema.getField("F23").schema(); + this.f240 = readerSchema.getField("F24").schema(); + this.f250 = readerSchema.getField("F25").schema(); + this.f260 = readerSchema.getField("F26").schema(); + this.f270 = readerSchema.getField("F27").schema(); + this.f280 = readerSchema.getField("F28").schema(); + this.f290 = readerSchema.getField("F29").schema(); + this.f300 = readerSchema.getField("F30").schema(); + this.f310 = readerSchema.getField("F31").schema(); + this.f320 = readerSchema.getField("F32").schema(); + this.f330 = readerSchema.getField("F33").schema(); + this.f340 = readerSchema.getField("F34").schema(); + this.f350 = readerSchema.getField("F35").schema(); + this.f360 = readerSchema.getField("F36").schema(); + this.f370 = readerSchema.getField("F37").schema(); + this.f380 = readerSchema.getField("F38").schema(); + this.f390 = readerSchema.getField("F39").schema(); + this.f400 = readerSchema.getField("F40").schema(); + this.f410 = readerSchema.getField("F41").schema(); + this.f420 = readerSchema.getField("F42").schema(); + this.f430 = readerSchema.getField("F43").schema(); + this.f440 = readerSchema.getField("F44").schema(); + this.f450 = readerSchema.getField("F45").schema(); + this.f460 = readerSchema.getField("F46").schema(); + this.f470 = readerSchema.getField("F47").schema(); + this.f480 = readerSchema.getField("F48").schema(); + this.f490 = readerSchema.getField("F49").schema(); + this.f500 = readerSchema.getField("F50").schema(); + this.f510 = readerSchema.getField("F51").schema(); + this.f520 = readerSchema.getField("F52").schema(); + this.f530 = readerSchema.getField("F53").schema(); + this.f540 = readerSchema.getField("F54").schema(); + this.f550 = readerSchema.getField("F55").schema(); + this.f560 = readerSchema.getField("F56").schema(); + this.f570 = readerSchema.getField("F57").schema(); + this.f580 = readerSchema.getField("F58").schema(); + this.f590 = readerSchema.getField("F59").schema(); + this.f600 = readerSchema.getField("F60").schema(); + this.f610 = readerSchema.getField("F61").schema(); + this.f620 = readerSchema.getField("F62").schema(); + this.f630 = readerSchema.getField("F63").schema(); + this.f640 = readerSchema.getField("F64").schema(); + this.f650 = readerSchema.getField("F65").schema(); + this.f660 = readerSchema.getField("F66").schema(); + this.f670 = readerSchema.getField("F67").schema(); + this.f680 = readerSchema.getField("F68").schema(); + this.f690 = readerSchema.getField("F69").schema(); + this.f700 = readerSchema.getField("F70").schema(); + this.f710 = readerSchema.getField("F71").schema(); + this.f720 = readerSchema.getField("F72").schema(); + this.f730 = readerSchema.getField("F73").schema(); + this.f740 = readerSchema.getField("F74").schema(); + this.f750 = readerSchema.getField("F75").schema(); + this.f760 = readerSchema.getField("F76").schema(); + this.f770 = readerSchema.getField("F77").schema(); + this.f780 = readerSchema.getField("F78").schema(); + this.f790 = readerSchema.getField("F79").schema(); + this.f800 = readerSchema.getField("F80").schema(); + this.f810 = readerSchema.getField("F81").schema(); + this.f820 = readerSchema.getField("F82").schema(); + this.f830 = readerSchema.getField("F83").schema(); + this.f840 = readerSchema.getField("F84").schema(); + this.f850 = readerSchema.getField("F85").schema(); + this.f860 = readerSchema.getField("F86").schema(); + this.f870 = readerSchema.getField("F87").schema(); + this.f880 = readerSchema.getField("F88").schema(); + this.f890 = readerSchema.getField("F89").schema(); + this.f900 = readerSchema.getField("F90").schema(); + this.f910 = readerSchema.getField("F91").schema(); + this.f920 = readerSchema.getField("F92").schema(); + this.f930 = readerSchema.getField("F93").schema(); + this.f940 = readerSchema.getField("F94").schema(); + this.f950 = readerSchema.getField("F95").schema(); + this.f960 = readerSchema.getField("F96").schema(); + this.f970 = readerSchema.getField("F97").schema(); + this.f980 = readerSchema.getField("F98").schema(); + this.f990 = readerSchema.getField("F99").schema(); + this.f1000 = readerSchema.getField("F100").schema(); + this.f1010 = readerSchema.getField("F101").schema(); + this.f1020 = readerSchema.getField("F102").schema(); + this.f1030 = readerSchema.getField("F103").schema(); + this.f1040 = readerSchema.getField("F104").schema(); + this.f1050 = readerSchema.getField("F105").schema(); + this.f1060 = readerSchema.getField("F106").schema(); + this.f1070 = readerSchema.getField("F107").schema(); + this.f1080 = readerSchema.getField("F108").schema(); + this.f1090 = readerSchema.getField("F109").schema(); + this.f1100 = readerSchema.getField("F110").schema(); + this.f1110 = readerSchema.getField("F111").schema(); + this.f1120 = readerSchema.getField("F112").schema(); + this.f1130 = readerSchema.getField("F113").schema(); + this.f1140 = readerSchema.getField("F114").schema(); + this.f1150 = readerSchema.getField("F115").schema(); + this.f1160 = readerSchema.getField("F116").schema(); + this.f1170 = readerSchema.getField("F117").schema(); + this.f1180 = readerSchema.getField("F118").schema(); + this.f1190 = readerSchema.getField("F119").schema(); + this.f1200 = readerSchema.getField("F120").schema(); + this.f1210 = readerSchema.getField("F121").schema(); + this.f1220 = readerSchema.getField("F122").schema(); + this.f1230 = readerSchema.getField("F123").schema(); + this.f1240 = readerSchema.getField("F124").schema(); + this.f1250 = readerSchema.getField("F125").schema(); + this.f1260 = readerSchema.getField("F126").schema(); + this.f1270 = readerSchema.getField("F127").schema(); + this.f1280 = readerSchema.getField("F128").schema(); + this.f1290 = readerSchema.getField("F129").schema(); + this.f1300 = readerSchema.getField("F130").schema(); + this.f1310 = readerSchema.getField("F131").schema(); + this.f1320 = readerSchema.getField("F132").schema(); + this.f1330 = readerSchema.getField("F133").schema(); + this.f1340 = readerSchema.getField("F134").schema(); + this.f1350 = readerSchema.getField("F135").schema(); + this.f1360 = readerSchema.getField("F136").schema(); + this.f1370 = readerSchema.getField("F137").schema(); + this.f1380 = readerSchema.getField("F138").schema(); + this.f1390 = readerSchema.getField("F139").schema(); + this.f1400 = readerSchema.getField("F140").schema(); + this.f1410 = readerSchema.getField("F141").schema(); + this.f1420 = readerSchema.getField("F142").schema(); + this.f1430 = readerSchema.getField("F143").schema(); + this.f1440 = readerSchema.getField("F144").schema(); + this.f1450 = readerSchema.getField("F145").schema(); + this.f1460 = readerSchema.getField("F146").schema(); + this.f1470 = readerSchema.getField("F147").schema(); + this.f1480 = readerSchema.getField("F148").schema(); + this.f1490 = readerSchema.getField("F149").schema(); + this.f1500 = readerSchema.getField("F150").schema(); + this.f1510 = readerSchema.getField("F151").schema(); + this.f1520 = readerSchema.getField("F152").schema(); + this.f1530 = readerSchema.getField("F153").schema(); + this.f1540 = readerSchema.getField("F154").schema(); + this.f1550 = readerSchema.getField("F155").schema(); + this.f1560 = readerSchema.getField("F156").schema(); + this.f1570 = readerSchema.getField("F157").schema(); + this.f1580 = readerSchema.getField("F158").schema(); + this.f1590 = readerSchema.getField("F159").schema(); + this.f1600 = readerSchema.getField("F160").schema(); + this.f1610 = readerSchema.getField("F161").schema(); + this.f1620 = readerSchema.getField("F162").schema(); + this.f1630 = readerSchema.getField("F163").schema(); + this.f1640 = readerSchema.getField("F164").schema(); + this.f1650 = readerSchema.getField("F165").schema(); + this.f1660 = readerSchema.getField("F166").schema(); + this.f1670 = readerSchema.getField("F167").schema(); + this.f1680 = readerSchema.getField("F168").schema(); + this.f1690 = readerSchema.getField("F169").schema(); + this.f1700 = readerSchema.getField("F170").schema(); + this.f1710 = readerSchema.getField("F171").schema(); + this.f1720 = readerSchema.getField("F172").schema(); + this.f1730 = readerSchema.getField("F173").schema(); + this.f1740 = readerSchema.getField("F174").schema(); + this.f1750 = readerSchema.getField("F175").schema(); + this.f1760 = readerSchema.getField("F176").schema(); + this.f1770 = readerSchema.getField("F177").schema(); + this.f1780 = readerSchema.getField("F178").schema(); + this.f1790 = readerSchema.getField("F179").schema(); + this.f1800 = readerSchema.getField("F180").schema(); + this.f1810 = readerSchema.getField("F181").schema(); + this.f1820 = readerSchema.getField("F182").schema(); + this.f1830 = readerSchema.getField("F183").schema(); + this.f1840 = readerSchema.getField("F184").schema(); + this.f1850 = readerSchema.getField("F185").schema(); + this.f1860 = readerSchema.getField("F186").schema(); + this.f1870 = readerSchema.getField("F187").schema(); + this.f1880 = readerSchema.getField("F188").schema(); + this.f1890 = readerSchema.getField("F189").schema(); + this.f1900 = readerSchema.getField("F190").schema(); + this.f1910 = readerSchema.getField("F191").schema(); + this.f1920 = readerSchema.getField("F192").schema(); + this.f1930 = readerSchema.getField("F193").schema(); + this.f1940 = readerSchema.getField("F194").schema(); + this.f1950 = readerSchema.getField("F195").schema(); + this.f1960 = readerSchema.getField("F196").schema(); + this.f1970 = readerSchema.getField("F197").schema(); + this.f1980 = readerSchema.getField("F198").schema(); + this.f1990 = readerSchema.getField("F199").schema(); + this.f2000 = readerSchema.getField("F200").schema(); + this.f2010 = readerSchema.getField("F201").schema(); + this.f2020 = readerSchema.getField("F202").schema(); + this.f2030 = readerSchema.getField("F203").schema(); + this.f2040 = readerSchema.getField("F204").schema(); + this.f2050 = readerSchema.getField("F205").schema(); + this.f2060 = readerSchema.getField("F206").schema(); + this.f2070 = readerSchema.getField("F207").schema(); + this.f2080 = readerSchema.getField("F208").schema(); + this.f2090 = readerSchema.getField("F209").schema(); + this.f2100 = readerSchema.getField("F210").schema(); + this.f2110 = readerSchema.getField("F211").schema(); + this.f2120 = readerSchema.getField("F212").schema(); + this.f2130 = readerSchema.getField("F213").schema(); + this.f2140 = readerSchema.getField("F214").schema(); + this.f2150 = readerSchema.getField("F215").schema(); + this.f2160 = readerSchema.getField("F216").schema(); + this.f2170 = readerSchema.getField("F217").schema(); + this.f2180 = readerSchema.getField("F218").schema(); + this.f2190 = readerSchema.getField("F219").schema(); + this.f2200 = readerSchema.getField("F220").schema(); + this.f2210 = readerSchema.getField("F221").schema(); + this.f2220 = readerSchema.getField("F222").schema(); + this.f2230 = readerSchema.getField("F223").schema(); + this.f2240 = readerSchema.getField("F224").schema(); + this.f2250 = readerSchema.getField("F225").schema(); + this.f2260 = readerSchema.getField("F226").schema(); + this.f2270 = readerSchema.getField("F227").schema(); + this.f2280 = readerSchema.getField("F228").schema(); + this.f2290 = readerSchema.getField("F229").schema(); + this.f2300 = readerSchema.getField("F230").schema(); + this.f2310 = readerSchema.getField("F231").schema(); + this.f2320 = readerSchema.getField("F232").schema(); + this.f2330 = readerSchema.getField("F233").schema(); + this.f2340 = readerSchema.getField("F234").schema(); + this.f2350 = readerSchema.getField("F235").schema(); + this.f2360 = readerSchema.getField("F236").schema(); + this.f2370 = readerSchema.getField("F237").schema(); + this.f2380 = readerSchema.getField("F238").schema(); + this.f2390 = readerSchema.getField("F239").schema(); + this.f2400 = readerSchema.getField("F240").schema(); + this.f2410 = readerSchema.getField("F241").schema(); + this.f2420 = readerSchema.getField("F242").schema(); + this.f2430 = readerSchema.getField("F243").schema(); + this.f2440 = readerSchema.getField("F244").schema(); + this.f2450 = readerSchema.getField("F245").schema(); + this.f2460 = readerSchema.getField("F246").schema(); + this.f2470 = readerSchema.getField("F247").schema(); + this.f2480 = readerSchema.getField("F248").schema(); + this.f2490 = readerSchema.getField("F249").schema(); + this.f2500 = readerSchema.getField("F250").schema(); + this.f2510 = readerSchema.getField("F251").schema(); + this.f2520 = readerSchema.getField("F252").schema(); + this.f2530 = readerSchema.getField("F253").schema(); + this.f2540 = readerSchema.getField("F254").schema(); + this.f2550 = readerSchema.getField("F255").schema(); + this.f2560 = readerSchema.getField("F256").schema(); + this.f2570 = readerSchema.getField("F257").schema(); + this.f2580 = readerSchema.getField("F258").schema(); + this.f2590 = readerSchema.getField("F259").schema(); + this.f2600 = readerSchema.getField("F260").schema(); + this.f2610 = readerSchema.getField("F261").schema(); + this.f2620 = readerSchema.getField("F262").schema(); + this.f2630 = readerSchema.getField("F263").schema(); + this.f2640 = readerSchema.getField("F264").schema(); + this.f2650 = readerSchema.getField("F265").schema(); + this.f2660 = readerSchema.getField("F266").schema(); + this.f2670 = readerSchema.getField("F267").schema(); + this.f2680 = readerSchema.getField("F268").schema(); + this.f2690 = readerSchema.getField("F269").schema(); + this.f2700 = readerSchema.getField("F270").schema(); + this.f2710 = readerSchema.getField("F271").schema(); + this.f2720 = readerSchema.getField("F272").schema(); + this.f2730 = readerSchema.getField("F273").schema(); + this.f2740 = readerSchema.getField("F274").schema(); + this.f2750 = readerSchema.getField("F275").schema(); + this.f2760 = readerSchema.getField("F276").schema(); + this.f2770 = readerSchema.getField("F277").schema(); + this.f2780 = readerSchema.getField("F278").schema(); + this.f2790 = readerSchema.getField("F279").schema(); + this.f2800 = readerSchema.getField("F280").schema(); + this.f2810 = readerSchema.getField("F281").schema(); + this.f2820 = readerSchema.getField("F282").schema(); + this.f2830 = readerSchema.getField("F283").schema(); + this.f2840 = readerSchema.getField("F284").schema(); + this.f2850 = readerSchema.getField("F285").schema(); + this.f2860 = readerSchema.getField("F286").schema(); + this.f2870 = readerSchema.getField("F287").schema(); + this.f2880 = readerSchema.getField("F288").schema(); + this.f2890 = readerSchema.getField("F289").schema(); + this.f2900 = readerSchema.getField("F290").schema(); + this.f2910 = readerSchema.getField("F291").schema(); + this.f2920 = readerSchema.getField("F292").schema(); + this.f2930 = readerSchema.getField("F293").schema(); + this.f2940 = readerSchema.getField("F294").schema(); + this.f2950 = readerSchema.getField("F295").schema(); + this.f2960 = readerSchema.getField("F296").schema(); + this.f2970 = readerSchema.getField("F297").schema(); + this.f2980 = readerSchema.getField("F298").schema(); + this.f2990 = readerSchema.getField("F299").schema(); + this.f3000 = readerSchema.getField("F300").schema(); + this.f3010 = readerSchema.getField("F301").schema(); + this.f3020 = readerSchema.getField("F302").schema(); + this.f3030 = readerSchema.getField("F303").schema(); + this.f3040 = readerSchema.getField("F304").schema(); + this.f3050 = readerSchema.getField("F305").schema(); + this.f3060 = readerSchema.getField("F306").schema(); + this.f3070 = readerSchema.getField("F307").schema(); + this.f3080 = readerSchema.getField("F308").schema(); + this.f3090 = readerSchema.getField("F309").schema(); + this.f3100 = readerSchema.getField("F310").schema(); + this.f3110 = readerSchema.getField("F311").schema(); + this.f3120 = readerSchema.getField("F312").schema(); + this.f3130 = readerSchema.getField("F313").schema(); + this.f3140 = readerSchema.getField("F314").schema(); + this.f3150 = readerSchema.getField("F315").schema(); + this.f3160 = readerSchema.getField("F316").schema(); + this.f3170 = readerSchema.getField("F317").schema(); + this.f3180 = readerSchema.getField("F318").schema(); + this.f3190 = readerSchema.getField("F319").schema(); + this.f3200 = readerSchema.getField("F320").schema(); + this.f3210 = readerSchema.getField("F321").schema(); + this.f3220 = readerSchema.getField("F322").schema(); + this.f3230 = readerSchema.getField("F323").schema(); + this.f3240 = readerSchema.getField("F324").schema(); + this.f3250 = readerSchema.getField("F325").schema(); + this.f3260 = readerSchema.getField("F326").schema(); + this.f3270 = readerSchema.getField("F327").schema(); + this.f3280 = readerSchema.getField("F328").schema(); + this.f3290 = readerSchema.getField("F329").schema(); + this.f3300 = readerSchema.getField("F330").schema(); + this.f3310 = readerSchema.getField("F331").schema(); + this.f3320 = readerSchema.getField("F332").schema(); + this.f3330 = readerSchema.getField("F333").schema(); + this.f3340 = readerSchema.getField("F334").schema(); + this.f3350 = readerSchema.getField("F335").schema(); + this.f3360 = readerSchema.getField("F336").schema(); + this.f3370 = readerSchema.getField("F337").schema(); + this.f3380 = readerSchema.getField("F338").schema(); + this.f3390 = readerSchema.getField("F339").schema(); + this.f3400 = readerSchema.getField("F340").schema(); + this.f3410 = readerSchema.getField("F341").schema(); + this.f3420 = readerSchema.getField("F342").schema(); + this.f3430 = readerSchema.getField("F343").schema(); + this.f3440 = readerSchema.getField("F344").schema(); + this.f3450 = readerSchema.getField("F345").schema(); + this.f3460 = readerSchema.getField("F346").schema(); + this.f3470 = readerSchema.getField("F347").schema(); + this.f3480 = readerSchema.getField("F348").schema(); + this.f3490 = readerSchema.getField("F349").schema(); + this.f3500 = readerSchema.getField("F350").schema(); + this.f3510 = readerSchema.getField("F351").schema(); + this.f3520 = readerSchema.getField("F352").schema(); + this.f3530 = readerSchema.getField("F353").schema(); + this.f3540 = readerSchema.getField("F354").schema(); + this.f3550 = readerSchema.getField("F355").schema(); + this.f3560 = readerSchema.getField("F356").schema(); + this.f3570 = readerSchema.getField("F357").schema(); + this.f3580 = readerSchema.getField("F358").schema(); + this.f3590 = readerSchema.getField("F359").schema(); + this.f3600 = readerSchema.getField("F360").schema(); + this.f3610 = readerSchema.getField("F361").schema(); + this.f3620 = readerSchema.getField("F362").schema(); + this.f3630 = readerSchema.getField("F363").schema(); + this.f3640 = readerSchema.getField("F364").schema(); + this.f3650 = readerSchema.getField("F365").schema(); + this.f3660 = readerSchema.getField("F366").schema(); + this.f3670 = readerSchema.getField("F367").schema(); + this.f3680 = readerSchema.getField("F368").schema(); + this.f3690 = readerSchema.getField("F369").schema(); + this.f3700 = readerSchema.getField("F370").schema(); + this.f3710 = readerSchema.getField("F371").schema(); + this.f3720 = readerSchema.getField("F372").schema(); + this.f3730 = readerSchema.getField("F373").schema(); + this.f3740 = readerSchema.getField("F374").schema(); + this.f3750 = readerSchema.getField("F375").schema(); + this.f3760 = readerSchema.getField("F376").schema(); + this.f3770 = readerSchema.getField("F377").schema(); + this.f3780 = readerSchema.getField("F378").schema(); + this.f3790 = readerSchema.getField("F379").schema(); + this.f3800 = readerSchema.getField("F380").schema(); + this.f3810 = readerSchema.getField("F381").schema(); + this.f3820 = readerSchema.getField("F382").schema(); + this.f3830 = readerSchema.getField("F383").schema(); + this.f3840 = readerSchema.getField("F384").schema(); + this.f3850 = readerSchema.getField("F385").schema(); + this.f3860 = readerSchema.getField("F386").schema(); + this.f3870 = readerSchema.getField("F387").schema(); + this.f3880 = readerSchema.getField("F388").schema(); + this.f3890 = readerSchema.getField("F389").schema(); + this.f3900 = readerSchema.getField("F390").schema(); + this.f3910 = readerSchema.getField("F391").schema(); + this.f3920 = readerSchema.getField("F392").schema(); + this.f3930 = readerSchema.getField("F393").schema(); + this.f3940 = readerSchema.getField("F394").schema(); + this.f3950 = readerSchema.getField("F395").schema(); + this.f3960 = readerSchema.getField("F396").schema(); + this.f3970 = readerSchema.getField("F397").schema(); + this.f3980 = readerSchema.getField("F398").schema(); + this.f3990 = readerSchema.getField("F399").schema(); + this.f4000 = readerSchema.getField("F400").schema(); + this.f4010 = readerSchema.getField("F401").schema(); + this.f4020 = readerSchema.getField("F402").schema(); + this.f4030 = readerSchema.getField("F403").schema(); + this.f4040 = readerSchema.getField("F404").schema(); + this.f4050 = readerSchema.getField("F405").schema(); + this.f4060 = readerSchema.getField("F406").schema(); + this.f4070 = readerSchema.getField("F407").schema(); + this.f4080 = readerSchema.getField("F408").schema(); + this.f4090 = readerSchema.getField("F409").schema(); + this.f4100 = readerSchema.getField("F410").schema(); + this.f4110 = readerSchema.getField("F411").schema(); + this.f4120 = readerSchema.getField("F412").schema(); + this.f4130 = readerSchema.getField("F413").schema(); + this.f4140 = readerSchema.getField("F414").schema(); + this.f4150 = readerSchema.getField("F415").schema(); + this.f4160 = readerSchema.getField("F416").schema(); + this.f4170 = readerSchema.getField("F417").schema(); + this.f4180 = readerSchema.getField("F418").schema(); + this.f4190 = readerSchema.getField("F419").schema(); + this.f4200 = readerSchema.getField("F420").schema(); + this.f4210 = readerSchema.getField("F421").schema(); + this.f4220 = readerSchema.getField("F422").schema(); + this.f4230 = readerSchema.getField("F423").schema(); + this.f4240 = readerSchema.getField("F424").schema(); + this.f4250 = readerSchema.getField("F425").schema(); + this.f4260 = readerSchema.getField("F426").schema(); + this.f4270 = readerSchema.getField("F427").schema(); + this.f4280 = readerSchema.getField("F428").schema(); + this.f4290 = readerSchema.getField("F429").schema(); + this.f4300 = readerSchema.getField("F430").schema(); + this.f4310 = readerSchema.getField("F431").schema(); + this.f4320 = readerSchema.getField("F432").schema(); + this.f4330 = readerSchema.getField("F433").schema(); + this.f4340 = readerSchema.getField("F434").schema(); + this.f4350 = readerSchema.getField("F435").schema(); + this.f4360 = readerSchema.getField("F436").schema(); + this.f4370 = readerSchema.getField("F437").schema(); + this.f4380 = readerSchema.getField("F438").schema(); + this.f4390 = readerSchema.getField("F439").schema(); + this.f4400 = readerSchema.getField("F440").schema(); + this.f4410 = readerSchema.getField("F441").schema(); + this.f4420 = readerSchema.getField("F442").schema(); + this.f4430 = readerSchema.getField("F443").schema(); + this.f4440 = readerSchema.getField("F444").schema(); + this.f4450 = readerSchema.getField("F445").schema(); + this.f4460 = readerSchema.getField("F446").schema(); + this.f4470 = readerSchema.getField("F447").schema(); + this.f4480 = readerSchema.getField("F448").schema(); + this.f4490 = readerSchema.getField("F449").schema(); + this.f4500 = readerSchema.getField("F450").schema(); + this.f4510 = readerSchema.getField("F451").schema(); + this.f4520 = readerSchema.getField("F452").schema(); + this.f4530 = readerSchema.getField("F453").schema(); + this.f4540 = readerSchema.getField("F454").schema(); + this.f4550 = readerSchema.getField("F455").schema(); + this.f4560 = readerSchema.getField("F456").schema(); + this.f4570 = readerSchema.getField("F457").schema(); + this.f4580 = readerSchema.getField("F458").schema(); + this.f4590 = readerSchema.getField("F459").schema(); + this.f4600 = readerSchema.getField("F460").schema(); + this.f4610 = readerSchema.getField("F461").schema(); + this.f4620 = readerSchema.getField("F462").schema(); + this.f4630 = readerSchema.getField("F463").schema(); + this.f4640 = readerSchema.getField("F464").schema(); + this.f4650 = readerSchema.getField("F465").schema(); + this.f4660 = readerSchema.getField("F466").schema(); + this.f4670 = readerSchema.getField("F467").schema(); + this.f4680 = readerSchema.getField("F468").schema(); + this.f4690 = readerSchema.getField("F469").schema(); + this.f4700 = readerSchema.getField("F470").schema(); + this.f4710 = readerSchema.getField("F471").schema(); + this.f4720 = readerSchema.getField("F472").schema(); + this.f4730 = readerSchema.getField("F473").schema(); + this.f4740 = readerSchema.getField("F474").schema(); + this.f4750 = readerSchema.getField("F475").schema(); + this.f4760 = readerSchema.getField("F476").schema(); + this.f4770 = readerSchema.getField("F477").schema(); + this.f4780 = readerSchema.getField("F478").schema(); + this.f4790 = readerSchema.getField("F479").schema(); + this.f4800 = readerSchema.getField("F480").schema(); + this.f4810 = readerSchema.getField("F481").schema(); + this.f4820 = readerSchema.getField("F482").schema(); + this.f4830 = readerSchema.getField("F483").schema(); + this.f4840 = readerSchema.getField("F484").schema(); + this.f4850 = readerSchema.getField("F485").schema(); + this.f4860 = readerSchema.getField("F486").schema(); + this.f4870 = readerSchema.getField("F487").schema(); + this.f4880 = readerSchema.getField("F488").schema(); + this.f4890 = readerSchema.getField("F489").schema(); + this.f4900 = readerSchema.getField("F490").schema(); + this.f4910 = readerSchema.getField("F491").schema(); + this.f4920 = readerSchema.getField("F492").schema(); + this.f4930 = readerSchema.getField("F493").schema(); + this.f4940 = readerSchema.getField("F494").schema(); + this.f4950 = readerSchema.getField("F495").schema(); + this.f4960 = readerSchema.getField("F496").schema(); + this.f4970 = readerSchema.getField("F497").schema(); + this.f4980 = readerSchema.getField("F498").schema(); + this.f4990 = readerSchema.getField("F499").schema(); + this.f5000 = readerSchema.getField("F500").schema(); + this.f5010 = readerSchema.getField("F501").schema(); + this.f5020 = readerSchema.getField("F502").schema(); + this.f5030 = readerSchema.getField("F503").schema(); + this.f5040 = readerSchema.getField("F504").schema(); + this.f5050 = readerSchema.getField("F505").schema(); + this.f5060 = readerSchema.getField("F506").schema(); + this.f5070 = readerSchema.getField("F507").schema(); + this.f5080 = readerSchema.getField("F508").schema(); + this.f5090 = readerSchema.getField("F509").schema(); + this.f5100 = readerSchema.getField("F510").schema(); + this.f5110 = readerSchema.getField("F511").schema(); + this.f5120 = readerSchema.getField("F512").schema(); + this.f5130 = readerSchema.getField("F513").schema(); + this.f5140 = readerSchema.getField("F514").schema(); + this.f5150 = readerSchema.getField("F515").schema(); + this.f5160 = readerSchema.getField("F516").schema(); + this.f5170 = readerSchema.getField("F517").schema(); + this.f5180 = readerSchema.getField("F518").schema(); + this.f5190 = readerSchema.getField("F519").schema(); + this.f5200 = readerSchema.getField("F520").schema(); + this.f5210 = readerSchema.getField("F521").schema(); + this.f5220 = readerSchema.getField("F522").schema(); + this.f5230 = readerSchema.getField("F523").schema(); + this.f5240 = readerSchema.getField("F524").schema(); + this.f5250 = readerSchema.getField("F525").schema(); + this.f5260 = readerSchema.getField("F526").schema(); + this.f5270 = readerSchema.getField("F527").schema(); + this.f5280 = readerSchema.getField("F528").schema(); + this.f5290 = readerSchema.getField("F529").schema(); + this.f5300 = readerSchema.getField("F530").schema(); + this.f5310 = readerSchema.getField("F531").schema(); + this.f5320 = readerSchema.getField("F532").schema(); + this.f5330 = readerSchema.getField("F533").schema(); + this.f5340 = readerSchema.getField("F534").schema(); + this.f5350 = readerSchema.getField("F535").schema(); + this.f5360 = readerSchema.getField("F536").schema(); + this.f5370 = readerSchema.getField("F537").schema(); + this.f5380 = readerSchema.getField("F538").schema(); + this.f5390 = readerSchema.getField("F539").schema(); + this.f5400 = readerSchema.getField("F540").schema(); + this.f5410 = readerSchema.getField("F541").schema(); + this.f5420 = readerSchema.getField("F542").schema(); + this.f5430 = readerSchema.getField("F543").schema(); + this.f5440 = readerSchema.getField("F544").schema(); + this.f5450 = readerSchema.getField("F545").schema(); + this.f5460 = readerSchema.getField("F546").schema(); + this.f5470 = readerSchema.getField("F547").schema(); + this.f5480 = readerSchema.getField("F548").schema(); + this.f5490 = readerSchema.getField("F549").schema(); + this.f5500 = readerSchema.getField("F550").schema(); + this.f5510 = readerSchema.getField("F551").schema(); + this.f5520 = readerSchema.getField("F552").schema(); + this.f5530 = readerSchema.getField("F553").schema(); + this.f5540 = readerSchema.getField("F554").schema(); + this.f5550 = readerSchema.getField("F555").schema(); + this.f5560 = readerSchema.getField("F556").schema(); + this.f5570 = readerSchema.getField("F557").schema(); + this.f5580 = readerSchema.getField("F558").schema(); + this.f5590 = readerSchema.getField("F559").schema(); + this.f5600 = readerSchema.getField("F560").schema(); + this.f5610 = readerSchema.getField("F561").schema(); + this.f5620 = readerSchema.getField("F562").schema(); + this.f5630 = readerSchema.getField("F563").schema(); + this.f5640 = readerSchema.getField("F564").schema(); + this.f5650 = readerSchema.getField("F565").schema(); + this.f5660 = readerSchema.getField("F566").schema(); + this.f5670 = readerSchema.getField("F567").schema(); + this.f5680 = readerSchema.getField("F568").schema(); + this.f5690 = readerSchema.getField("F569").schema(); + this.f5700 = readerSchema.getField("F570").schema(); + this.f5710 = readerSchema.getField("F571").schema(); + this.f5720 = readerSchema.getField("F572").schema(); + this.f5730 = readerSchema.getField("F573").schema(); + this.f5740 = readerSchema.getField("F574").schema(); + this.f5750 = readerSchema.getField("F575").schema(); + this.f5760 = readerSchema.getField("F576").schema(); + this.f5770 = readerSchema.getField("F577").schema(); + this.f5780 = readerSchema.getField("F578").schema(); + this.f5790 = readerSchema.getField("F579").schema(); + this.f5800 = readerSchema.getField("F580").schema(); + this.f5810 = readerSchema.getField("F581").schema(); + this.f5820 = readerSchema.getField("F582").schema(); + this.f5830 = readerSchema.getField("F583").schema(); + this.f5840 = readerSchema.getField("F584").schema(); + this.f5850 = readerSchema.getField("F585").schema(); + this.f5860 = readerSchema.getField("F586").schema(); + this.f5870 = readerSchema.getField("F587").schema(); + this.f5880 = readerSchema.getField("F588").schema(); + this.f5890 = readerSchema.getField("F589").schema(); + this.f5900 = readerSchema.getField("F590").schema(); + this.f5910 = readerSchema.getField("F591").schema(); + this.f5920 = readerSchema.getField("F592").schema(); + this.f5930 = readerSchema.getField("F593").schema(); + this.f5940 = readerSchema.getField("F594").schema(); + this.f5950 = readerSchema.getField("F595").schema(); + this.f5960 = readerSchema.getField("F596").schema(); + this.f5970 = readerSchema.getField("F597").schema(); + this.f5980 = readerSchema.getField("F598").schema(); + this.f5990 = readerSchema.getField("F599").schema(); + this.f6000 = readerSchema.getField("F600").schema(); + this.f6010 = readerSchema.getField("F601").schema(); + this.f6020 = readerSchema.getField("F602").schema(); + this.f6030 = readerSchema.getField("F603").schema(); + this.f6040 = readerSchema.getField("F604").schema(); + this.f6050 = readerSchema.getField("F605").schema(); + this.f6060 = readerSchema.getField("F606").schema(); + this.f6070 = readerSchema.getField("F607").schema(); + this.f6080 = readerSchema.getField("F608").schema(); + this.f6090 = readerSchema.getField("F609").schema(); + this.f6100 = readerSchema.getField("F610").schema(); + this.f6110 = readerSchema.getField("F611").schema(); + this.f6120 = readerSchema.getField("F612").schema(); + this.f6130 = readerSchema.getField("F613").schema(); + this.f6140 = readerSchema.getField("F614").schema(); + this.f6150 = readerSchema.getField("F615").schema(); + this.f6160 = readerSchema.getField("F616").schema(); + this.f6170 = readerSchema.getField("F617").schema(); + this.f6180 = readerSchema.getField("F618").schema(); + this.f6190 = readerSchema.getField("F619").schema(); + this.f6200 = readerSchema.getField("F620").schema(); + this.f6210 = readerSchema.getField("F621").schema(); + this.f6220 = readerSchema.getField("F622").schema(); + this.f6230 = readerSchema.getField("F623").schema(); + this.f6240 = readerSchema.getField("F624").schema(); + this.f6250 = readerSchema.getField("F625").schema(); + this.f6260 = readerSchema.getField("F626").schema(); + this.f6270 = readerSchema.getField("F627").schema(); + this.f6280 = readerSchema.getField("F628").schema(); + this.f6290 = readerSchema.getField("F629").schema(); + this.f6300 = readerSchema.getField("F630").schema(); + this.f6310 = readerSchema.getField("F631").schema(); + this.f6320 = readerSchema.getField("F632").schema(); + this.f6330 = readerSchema.getField("F633").schema(); + this.f6340 = readerSchema.getField("F634").schema(); + this.f6350 = readerSchema.getField("F635").schema(); + this.f6360 = readerSchema.getField("F636").schema(); + this.f6370 = readerSchema.getField("F637").schema(); + this.f6380 = readerSchema.getField("F638").schema(); + this.f6390 = readerSchema.getField("F639").schema(); + this.f6400 = readerSchema.getField("F640").schema(); + this.f6410 = readerSchema.getField("F641").schema(); + this.f6420 = readerSchema.getField("F642").schema(); + this.f6430 = readerSchema.getField("F643").schema(); + this.f6440 = readerSchema.getField("F644").schema(); + this.f6450 = readerSchema.getField("F645").schema(); + this.f6460 = readerSchema.getField("F646").schema(); + this.f6470 = readerSchema.getField("F647").schema(); + this.f6480 = readerSchema.getField("F648").schema(); + this.f6490 = readerSchema.getField("F649").schema(); + this.f6500 = readerSchema.getField("F650").schema(); + this.f6510 = readerSchema.getField("F651").schema(); + this.f6520 = readerSchema.getField("F652").schema(); + this.f6530 = readerSchema.getField("F653").schema(); + this.f6540 = readerSchema.getField("F654").schema(); + this.f6550 = readerSchema.getField("F655").schema(); + this.f6560 = readerSchema.getField("F656").schema(); + this.f6570 = readerSchema.getField("F657").schema(); + this.f6580 = readerSchema.getField("F658").schema(); + this.f6590 = readerSchema.getField("F659").schema(); + this.f6600 = readerSchema.getField("F660").schema(); + this.f6610 = readerSchema.getField("F661").schema(); + this.f6620 = readerSchema.getField("F662").schema(); + this.f6630 = readerSchema.getField("F663").schema(); + this.f6640 = readerSchema.getField("F664").schema(); + this.f6650 = readerSchema.getField("F665").schema(); + this.f6660 = readerSchema.getField("F666").schema(); + this.f6670 = readerSchema.getField("F667").schema(); + this.f6680 = readerSchema.getField("F668").schema(); + this.f6690 = readerSchema.getField("F669").schema(); + this.f6700 = readerSchema.getField("F670").schema(); + this.f6710 = readerSchema.getField("F671").schema(); + this.f6720 = readerSchema.getField("F672").schema(); + this.f6730 = readerSchema.getField("F673").schema(); + this.f6740 = readerSchema.getField("F674").schema(); + this.f6750 = readerSchema.getField("F675").schema(); + this.f6760 = readerSchema.getField("F676").schema(); + this.f6770 = readerSchema.getField("F677").schema(); + this.f6780 = readerSchema.getField("F678").schema(); + this.f6790 = readerSchema.getField("F679").schema(); + this.f6800 = readerSchema.getField("F680").schema(); + this.f6810 = readerSchema.getField("F681").schema(); + this.f6820 = readerSchema.getField("F682").schema(); + this.f6830 = readerSchema.getField("F683").schema(); + this.f6840 = readerSchema.getField("F684").schema(); + this.f6850 = readerSchema.getField("F685").schema(); + this.f6860 = readerSchema.getField("F686").schema(); + this.f6870 = readerSchema.getField("F687").schema(); + this.f6880 = readerSchema.getField("F688").schema(); + this.f6890 = readerSchema.getField("F689").schema(); + this.f6900 = readerSchema.getField("F690").schema(); + this.f6910 = readerSchema.getField("F691").schema(); + this.f6920 = readerSchema.getField("F692").schema(); + this.f6930 = readerSchema.getField("F693").schema(); + this.f6940 = readerSchema.getField("F694").schema(); + this.f6950 = readerSchema.getField("F695").schema(); + this.f6960 = readerSchema.getField("F696").schema(); + this.f6970 = readerSchema.getField("F697").schema(); + this.f6980 = readerSchema.getField("F698").schema(); + this.f6990 = readerSchema.getField("F699").schema(); + this.f7000 = readerSchema.getField("F700").schema(); + this.f7010 = readerSchema.getField("F701").schema(); + this.f7020 = readerSchema.getField("F702").schema(); + this.f7030 = readerSchema.getField("F703").schema(); + this.f7040 = readerSchema.getField("F704").schema(); + this.f7050 = readerSchema.getField("F705").schema(); + this.f7060 = readerSchema.getField("F706").schema(); + this.f7070 = readerSchema.getField("F707").schema(); + this.f7080 = readerSchema.getField("F708").schema(); + this.f7090 = readerSchema.getField("F709").schema(); + this.f7100 = readerSchema.getField("F710").schema(); + this.f7110 = readerSchema.getField("F711").schema(); + this.f7120 = readerSchema.getField("F712").schema(); + this.f7130 = readerSchema.getField("F713").schema(); + this.f7140 = readerSchema.getField("F714").schema(); + this.f7150 = readerSchema.getField("F715").schema(); + this.f7160 = readerSchema.getField("F716").schema(); + this.f7170 = readerSchema.getField("F717").schema(); + this.f7180 = readerSchema.getField("F718").schema(); + this.f7190 = readerSchema.getField("F719").schema(); + this.f7200 = readerSchema.getField("F720").schema(); + this.f7210 = readerSchema.getField("F721").schema(); + this.f7220 = readerSchema.getField("F722").schema(); + this.f7230 = readerSchema.getField("F723").schema(); + this.f7240 = readerSchema.getField("F724").schema(); + this.f7250 = readerSchema.getField("F725").schema(); + this.f7260 = readerSchema.getField("F726").schema(); + this.f7270 = readerSchema.getField("F727").schema(); + this.f7280 = readerSchema.getField("F728").schema(); + this.f7290 = readerSchema.getField("F729").schema(); + this.f7300 = readerSchema.getField("F730").schema(); + this.f7310 = readerSchema.getField("F731").schema(); + this.f7320 = readerSchema.getField("F732").schema(); + this.f7330 = readerSchema.getField("F733").schema(); + this.f7340 = readerSchema.getField("F734").schema(); + this.f7350 = readerSchema.getField("F735").schema(); + this.f7360 = readerSchema.getField("F736").schema(); + this.f7370 = readerSchema.getField("F737").schema(); + this.f7380 = readerSchema.getField("F738").schema(); + this.f7390 = readerSchema.getField("F739").schema(); + this.f7400 = readerSchema.getField("F740").schema(); + this.f7410 = readerSchema.getField("F741").schema(); + this.f7420 = readerSchema.getField("F742").schema(); + this.f7430 = readerSchema.getField("F743").schema(); + this.f7440 = readerSchema.getField("F744").schema(); + this.f7450 = readerSchema.getField("F745").schema(); + this.f7460 = readerSchema.getField("F746").schema(); + this.f7470 = readerSchema.getField("F747").schema(); + this.f7480 = readerSchema.getField("F748").schema(); + this.f7490 = readerSchema.getField("F749").schema(); + this.f7500 = readerSchema.getField("F750").schema(); + this.f7510 = readerSchema.getField("F751").schema(); + this.f7520 = readerSchema.getField("F752").schema(); + this.f7530 = readerSchema.getField("F753").schema(); + this.f7540 = readerSchema.getField("F754").schema(); + this.f7550 = readerSchema.getField("F755").schema(); + this.f7560 = readerSchema.getField("F756").schema(); + this.f7570 = readerSchema.getField("F757").schema(); + this.f7580 = readerSchema.getField("F758").schema(); + this.f7590 = readerSchema.getField("F759").schema(); + this.f7600 = readerSchema.getField("F760").schema(); + this.f7610 = readerSchema.getField("F761").schema(); + this.f7620 = readerSchema.getField("F762").schema(); + this.f7630 = readerSchema.getField("F763").schema(); + this.f7640 = readerSchema.getField("F764").schema(); + this.f7650 = readerSchema.getField("F765").schema(); + this.f7660 = readerSchema.getField("F766").schema(); + this.f7670 = readerSchema.getField("F767").schema(); + this.f7680 = readerSchema.getField("F768").schema(); + this.f7690 = readerSchema.getField("F769").schema(); + this.f7700 = readerSchema.getField("F770").schema(); + this.f7710 = readerSchema.getField("F771").schema(); + this.f7720 = readerSchema.getField("F772").schema(); + this.f7730 = readerSchema.getField("F773").schema(); + this.f7740 = readerSchema.getField("F774").schema(); + this.f7750 = readerSchema.getField("F775").schema(); + this.f7760 = readerSchema.getField("F776").schema(); + this.f7770 = readerSchema.getField("F777").schema(); + this.f7780 = readerSchema.getField("F778").schema(); + this.f7790 = readerSchema.getField("F779").schema(); + this.f7800 = readerSchema.getField("F780").schema(); + this.f7810 = readerSchema.getField("F781").schema(); + this.f7820 = readerSchema.getField("F782").schema(); + this.f7830 = readerSchema.getField("F783").schema(); + this.f7840 = readerSchema.getField("F784").schema(); + this.f7850 = readerSchema.getField("F785").schema(); + this.f7860 = readerSchema.getField("F786").schema(); + this.f7870 = readerSchema.getField("F787").schema(); + this.f7880 = readerSchema.getField("F788").schema(); + this.f7890 = readerSchema.getField("F789").schema(); + this.f7900 = readerSchema.getField("F790").schema(); + this.f7910 = readerSchema.getField("F791").schema(); + this.f7920 = readerSchema.getField("F792").schema(); + this.f7930 = readerSchema.getField("F793").schema(); + this.f7940 = readerSchema.getField("F794").schema(); + this.f7950 = readerSchema.getField("F795").schema(); + this.f7960 = readerSchema.getField("F796").schema(); + this.f7970 = readerSchema.getField("F797").schema(); + this.f7980 = readerSchema.getField("F798").schema(); + this.f7990 = readerSchema.getField("F799").schema(); + this.f8000 = readerSchema.getField("F800").schema(); + this.f8010 = readerSchema.getField("F801").schema(); + this.f8020 = readerSchema.getField("F802").schema(); + this.f8030 = readerSchema.getField("F803").schema(); + this.f8040 = readerSchema.getField("F804").schema(); + this.f8050 = readerSchema.getField("F805").schema(); + this.f8060 = readerSchema.getField("F806").schema(); + this.f8070 = readerSchema.getField("F807").schema(); + this.f8080 = readerSchema.getField("F808").schema(); + this.f8090 = readerSchema.getField("F809").schema(); + this.f8100 = readerSchema.getField("F810").schema(); + this.f8110 = readerSchema.getField("F811").schema(); + this.f8120 = readerSchema.getField("F812").schema(); + this.f8130 = readerSchema.getField("F813").schema(); + this.f8140 = readerSchema.getField("F814").schema(); + this.f8150 = readerSchema.getField("F815").schema(); + this.f8160 = readerSchema.getField("F816").schema(); + this.f8170 = readerSchema.getField("F817").schema(); + this.f8180 = readerSchema.getField("F818").schema(); + this.f8190 = readerSchema.getField("F819").schema(); + this.f8200 = readerSchema.getField("F820").schema(); + this.f8210 = readerSchema.getField("F821").schema(); + this.f8220 = readerSchema.getField("F822").schema(); + this.f8230 = readerSchema.getField("F823").schema(); + this.f8240 = readerSchema.getField("F824").schema(); + this.f8250 = readerSchema.getField("F825").schema(); + this.f8260 = readerSchema.getField("F826").schema(); + this.f8270 = readerSchema.getField("F827").schema(); + this.f8280 = readerSchema.getField("F828").schema(); + this.f8290 = readerSchema.getField("F829").schema(); + this.f8300 = readerSchema.getField("F830").schema(); + this.f8310 = readerSchema.getField("F831").schema(); + this.f8320 = readerSchema.getField("F832").schema(); + this.f8330 = readerSchema.getField("F833").schema(); + this.f8340 = readerSchema.getField("F834").schema(); + this.f8350 = readerSchema.getField("F835").schema(); + this.f8360 = readerSchema.getField("F836").schema(); + this.f8370 = readerSchema.getField("F837").schema(); + this.f8380 = readerSchema.getField("F838").schema(); + this.f8390 = readerSchema.getField("F839").schema(); + this.f8400 = readerSchema.getField("F840").schema(); + this.f8410 = readerSchema.getField("F841").schema(); + this.f8420 = readerSchema.getField("F842").schema(); + this.f8430 = readerSchema.getField("F843").schema(); + this.f8440 = readerSchema.getField("F844").schema(); + this.f8450 = readerSchema.getField("F845").schema(); + this.f8460 = readerSchema.getField("F846").schema(); + this.f8470 = readerSchema.getField("F847").schema(); + this.f8480 = readerSchema.getField("F848").schema(); + this.f8490 = readerSchema.getField("F849").schema(); + this.f8500 = readerSchema.getField("F850").schema(); + this.f8510 = readerSchema.getField("F851").schema(); + this.f8520 = readerSchema.getField("F852").schema(); + this.f8530 = readerSchema.getField("F853").schema(); + this.f8540 = readerSchema.getField("F854").schema(); + this.f8550 = readerSchema.getField("F855").schema(); + this.f8560 = readerSchema.getField("F856").schema(); + this.f8570 = readerSchema.getField("F857").schema(); + this.f8580 = readerSchema.getField("F858").schema(); + this.f8590 = readerSchema.getField("F859").schema(); + this.f8600 = readerSchema.getField("F860").schema(); + this.f8610 = readerSchema.getField("F861").schema(); + this.f8620 = readerSchema.getField("F862").schema(); + this.f8630 = readerSchema.getField("F863").schema(); + this.f8640 = readerSchema.getField("F864").schema(); + this.f8650 = readerSchema.getField("F865").schema(); + this.f8660 = readerSchema.getField("F866").schema(); + this.f8670 = readerSchema.getField("F867").schema(); + this.f8680 = readerSchema.getField("F868").schema(); + this.f8690 = readerSchema.getField("F869").schema(); + this.f8700 = readerSchema.getField("F870").schema(); + this.f8710 = readerSchema.getField("F871").schema(); + this.f8720 = readerSchema.getField("F872").schema(); + this.f8730 = readerSchema.getField("F873").schema(); + this.f8740 = readerSchema.getField("F874").schema(); + this.f8750 = readerSchema.getField("F875").schema(); + this.f8760 = readerSchema.getField("F876").schema(); + this.f8770 = readerSchema.getField("F877").schema(); + this.f8780 = readerSchema.getField("F878").schema(); + this.f8790 = readerSchema.getField("F879").schema(); + this.f8800 = readerSchema.getField("F880").schema(); + this.f8810 = readerSchema.getField("F881").schema(); + this.f8820 = readerSchema.getField("F882").schema(); + this.f8830 = readerSchema.getField("F883").schema(); + this.f8840 = readerSchema.getField("F884").schema(); + this.f8850 = readerSchema.getField("F885").schema(); + this.f8860 = readerSchema.getField("F886").schema(); + this.f8870 = readerSchema.getField("F887").schema(); + this.f8880 = readerSchema.getField("F888").schema(); + this.f8890 = readerSchema.getField("F889").schema(); + this.f8900 = readerSchema.getField("F890").schema(); + this.f8910 = readerSchema.getField("F891").schema(); + this.f8920 = readerSchema.getField("F892").schema(); + this.f8930 = readerSchema.getField("F893").schema(); + this.f8940 = readerSchema.getField("F894").schema(); + this.f8950 = readerSchema.getField("F895").schema(); + this.f8960 = readerSchema.getField("F896").schema(); + this.f8970 = readerSchema.getField("F897").schema(); + this.f8980 = readerSchema.getField("F898").schema(); + this.f8990 = readerSchema.getField("F899").schema(); + this.f9000 = readerSchema.getField("F900").schema(); + this.f9010 = readerSchema.getField("F901").schema(); + this.f9020 = readerSchema.getField("F902").schema(); + this.f9030 = readerSchema.getField("F903").schema(); + this.f9040 = readerSchema.getField("F904").schema(); + this.f9050 = readerSchema.getField("F905").schema(); + this.f9060 = readerSchema.getField("F906").schema(); + this.f9070 = readerSchema.getField("F907").schema(); + this.f9080 = readerSchema.getField("F908").schema(); + this.f9090 = readerSchema.getField("F909").schema(); + this.f9100 = readerSchema.getField("F910").schema(); + this.f9110 = readerSchema.getField("F911").schema(); + this.f9120 = readerSchema.getField("F912").schema(); + this.f9130 = readerSchema.getField("F913").schema(); + this.f9140 = readerSchema.getField("F914").schema(); + this.f9150 = readerSchema.getField("F915").schema(); + this.f9160 = readerSchema.getField("F916").schema(); + this.f9170 = readerSchema.getField("F917").schema(); + this.f9180 = readerSchema.getField("F918").schema(); + this.f9190 = readerSchema.getField("F919").schema(); + this.f9200 = readerSchema.getField("F920").schema(); + this.f9210 = readerSchema.getField("F921").schema(); + this.f9220 = readerSchema.getField("F922").schema(); + this.f9230 = readerSchema.getField("F923").schema(); + this.f9240 = readerSchema.getField("F924").schema(); + this.f9250 = readerSchema.getField("F925").schema(); + this.f9260 = readerSchema.getField("F926").schema(); + this.f9270 = readerSchema.getField("F927").schema(); + this.f9280 = readerSchema.getField("F928").schema(); + this.f9290 = readerSchema.getField("F929").schema(); + this.f9300 = readerSchema.getField("F930").schema(); + this.f9310 = readerSchema.getField("F931").schema(); + this.f9320 = readerSchema.getField("F932").schema(); + this.f9330 = readerSchema.getField("F933").schema(); + this.f9340 = readerSchema.getField("F934").schema(); + this.f9350 = readerSchema.getField("F935").schema(); + this.f9360 = readerSchema.getField("F936").schema(); + this.f9370 = readerSchema.getField("F937").schema(); + this.f9380 = readerSchema.getField("F938").schema(); + this.f9390 = readerSchema.getField("F939").schema(); + this.f9400 = readerSchema.getField("F940").schema(); + this.f9410 = readerSchema.getField("F941").schema(); + this.f9420 = readerSchema.getField("F942").schema(); + this.f9430 = readerSchema.getField("F943").schema(); + this.f9440 = readerSchema.getField("F944").schema(); + this.f9450 = readerSchema.getField("F945").schema(); + this.f9460 = readerSchema.getField("F946").schema(); + this.f9470 = readerSchema.getField("F947").schema(); + this.f9480 = readerSchema.getField("F948").schema(); + this.f9490 = readerSchema.getField("F949").schema(); + this.f9500 = readerSchema.getField("F950").schema(); + this.f9510 = readerSchema.getField("F951").schema(); + this.f9520 = readerSchema.getField("F952").schema(); + this.f9530 = readerSchema.getField("F953").schema(); + this.f9540 = readerSchema.getField("F954").schema(); + this.f9550 = readerSchema.getField("F955").schema(); + this.f9560 = readerSchema.getField("F956").schema(); + this.f9570 = readerSchema.getField("F957").schema(); + this.f9580 = readerSchema.getField("F958").schema(); + this.f9590 = readerSchema.getField("F959").schema(); + this.f9600 = readerSchema.getField("F960").schema(); + this.f9610 = readerSchema.getField("F961").schema(); + this.f9620 = readerSchema.getField("F962").schema(); + this.f9630 = readerSchema.getField("F963").schema(); + this.f9640 = readerSchema.getField("F964").schema(); + this.f9650 = readerSchema.getField("F965").schema(); + this.f9660 = readerSchema.getField("F966").schema(); + this.f9670 = readerSchema.getField("F967").schema(); + this.f9680 = readerSchema.getField("F968").schema(); + this.f9690 = readerSchema.getField("F969").schema(); + this.f9700 = readerSchema.getField("F970").schema(); + this.f9710 = readerSchema.getField("F971").schema(); + this.f9720 = readerSchema.getField("F972").schema(); + this.f9730 = readerSchema.getField("F973").schema(); + this.f9740 = readerSchema.getField("F974").schema(); + this.f9750 = readerSchema.getField("F975").schema(); + this.f9760 = readerSchema.getField("F976").schema(); + this.f9770 = readerSchema.getField("F977").schema(); + this.f9780 = readerSchema.getField("F978").schema(); + this.f9790 = readerSchema.getField("F979").schema(); + this.f9800 = readerSchema.getField("F980").schema(); + this.f9810 = readerSchema.getField("F981").schema(); + this.f9820 = readerSchema.getField("F982").schema(); + this.f9830 = readerSchema.getField("F983").schema(); + this.f9840 = readerSchema.getField("F984").schema(); + this.f9850 = readerSchema.getField("F985").schema(); + this.f9860 = readerSchema.getField("F986").schema(); + this.f9870 = readerSchema.getField("F987").schema(); + this.f9880 = readerSchema.getField("F988").schema(); + this.f9890 = readerSchema.getField("F989").schema(); + this.f9900 = readerSchema.getField("F990").schema(); + this.f9910 = readerSchema.getField("F991").schema(); + this.f9920 = readerSchema.getField("F992").schema(); + this.f9930 = readerSchema.getField("F993").schema(); + this.f9940 = readerSchema.getField("F994").schema(); + this.f9950 = readerSchema.getField("F995").schema(); + this.f9960 = readerSchema.getField("F996").schema(); + this.f9970 = readerSchema.getField("F997").schema(); + this.f9980 = readerSchema.getField("F998").schema(); + this.f9990 = readerSchema.getField("F999").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'F0': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(1, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'F1': "+ unionIndex1)); + } + } + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(2, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence2; + Object oldString2 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(2); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(2, charSequence2); + } else { + throw new RuntimeException(("Illegal union index for 'F2': "+ unionIndex2)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(3, null); + } else { + if (unionIndex3 == 1) { + Utf8 charSequence3; + Object oldString3 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(3); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(3, charSequence3); + } else { + throw new RuntimeException(("Illegal union index for 'F3': "+ unionIndex3)); + } + } + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(4, null); + } else { + if (unionIndex4 == 1) { + Utf8 charSequence4; + Object oldString4 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(4); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(4, charSequence4); + } else { + throw new RuntimeException(("Illegal union index for 'F4': "+ unionIndex4)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(5, null); + } else { + if (unionIndex5 == 1) { + Utf8 charSequence5; + Object oldString5 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(5); + if (oldString5 instanceof Utf8) { + charSequence5 = (decoder).readString(((Utf8) oldString5)); + } else { + charSequence5 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(5, charSequence5); + } else { + throw new RuntimeException(("Illegal union index for 'F5': "+ unionIndex5)); + } + } + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(6, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence6; + Object oldString6 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(6); + if (oldString6 instanceof Utf8) { + charSequence6 = (decoder).readString(((Utf8) oldString6)); + } else { + charSequence6 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(6, charSequence6); + } else { + throw new RuntimeException(("Illegal union index for 'F6': "+ unionIndex6)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(7, null); + } else { + if (unionIndex7 == 1) { + Utf8 charSequence7; + Object oldString7 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(7); + if (oldString7 instanceof Utf8) { + charSequence7 = (decoder).readString(((Utf8) oldString7)); + } else { + charSequence7 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(7, charSequence7); + } else { + throw new RuntimeException(("Illegal union index for 'F7': "+ unionIndex7)); + } + } + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(8, null); + } else { + if (unionIndex8 == 1) { + Utf8 charSequence8; + Object oldString8 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(8); + if (oldString8 instanceof Utf8) { + charSequence8 = (decoder).readString(((Utf8) oldString8)); + } else { + charSequence8 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(8, charSequence8); + } else { + throw new RuntimeException(("Illegal union index for 'F8': "+ unionIndex8)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex9 = (decoder.readIndex()); + if (unionIndex9 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(9, null); + } else { + if (unionIndex9 == 1) { + Utf8 charSequence9; + Object oldString9 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(9); + if (oldString9 instanceof Utf8) { + charSequence9 = (decoder).readString(((Utf8) oldString9)); + } else { + charSequence9 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(9, charSequence9); + } else { + throw new RuntimeException(("Illegal union index for 'F9': "+ unionIndex9)); + } + } + int unionIndex10 = (decoder.readIndex()); + if (unionIndex10 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(10, null); + } else { + if (unionIndex10 == 1) { + Utf8 charSequence10; + Object oldString10 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(10); + if (oldString10 instanceof Utf8) { + charSequence10 = (decoder).readString(((Utf8) oldString10)); + } else { + charSequence10 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(10, charSequence10); + } else { + throw new RuntimeException(("Illegal union index for 'F10': "+ unionIndex10)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex11 = (decoder.readIndex()); + if (unionIndex11 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(11, null); + } else { + if (unionIndex11 == 1) { + Utf8 charSequence11; + Object oldString11 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(11); + if (oldString11 instanceof Utf8) { + charSequence11 = (decoder).readString(((Utf8) oldString11)); + } else { + charSequence11 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(11, charSequence11); + } else { + throw new RuntimeException(("Illegal union index for 'F11': "+ unionIndex11)); + } + } + int unionIndex12 = (decoder.readIndex()); + if (unionIndex12 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(12, null); + } else { + if (unionIndex12 == 1) { + Utf8 charSequence12; + Object oldString12 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(12); + if (oldString12 instanceof Utf8) { + charSequence12 = (decoder).readString(((Utf8) oldString12)); + } else { + charSequence12 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(12, charSequence12); + } else { + throw new RuntimeException(("Illegal union index for 'F12': "+ unionIndex12)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex13 = (decoder.readIndex()); + if (unionIndex13 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(13, null); + } else { + if (unionIndex13 == 1) { + Utf8 charSequence13; + Object oldString13 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(13); + if (oldString13 instanceof Utf8) { + charSequence13 = (decoder).readString(((Utf8) oldString13)); + } else { + charSequence13 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(13, charSequence13); + } else { + throw new RuntimeException(("Illegal union index for 'F13': "+ unionIndex13)); + } + } + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(14, null); + } else { + if (unionIndex14 == 1) { + Utf8 charSequence14; + Object oldString14 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(14); + if (oldString14 instanceof Utf8) { + charSequence14 = (decoder).readString(((Utf8) oldString14)); + } else { + charSequence14 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(14, charSequence14); + } else { + throw new RuntimeException(("Illegal union index for 'F14': "+ unionIndex14)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(15, null); + } else { + if (unionIndex15 == 1) { + Utf8 charSequence15; + Object oldString15 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(15); + if (oldString15 instanceof Utf8) { + charSequence15 = (decoder).readString(((Utf8) oldString15)); + } else { + charSequence15 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(15, charSequence15); + } else { + throw new RuntimeException(("Illegal union index for 'F15': "+ unionIndex15)); + } + } + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(16, null); + } else { + if (unionIndex16 == 1) { + Utf8 charSequence16; + Object oldString16 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(16); + if (oldString16 instanceof Utf8) { + charSequence16 = (decoder).readString(((Utf8) oldString16)); + } else { + charSequence16 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(16, charSequence16); + } else { + throw new RuntimeException(("Illegal union index for 'F16': "+ unionIndex16)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex17 = (decoder.readIndex()); + if (unionIndex17 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(17, null); + } else { + if (unionIndex17 == 1) { + Utf8 charSequence17; + Object oldString17 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(17); + if (oldString17 instanceof Utf8) { + charSequence17 = (decoder).readString(((Utf8) oldString17)); + } else { + charSequence17 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(17, charSequence17); + } else { + throw new RuntimeException(("Illegal union index for 'F17': "+ unionIndex17)); + } + } + int unionIndex18 = (decoder.readIndex()); + if (unionIndex18 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(18, null); + } else { + if (unionIndex18 == 1) { + Utf8 charSequence18; + Object oldString18 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(18); + if (oldString18 instanceof Utf8) { + charSequence18 = (decoder).readString(((Utf8) oldString18)); + } else { + charSequence18 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(18, charSequence18); + } else { + throw new RuntimeException(("Illegal union index for 'F18': "+ unionIndex18)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex19 = (decoder.readIndex()); + if (unionIndex19 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(19, null); + } else { + if (unionIndex19 == 1) { + Utf8 charSequence19; + Object oldString19 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(19); + if (oldString19 instanceof Utf8) { + charSequence19 = (decoder).readString(((Utf8) oldString19)); + } else { + charSequence19 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(19, charSequence19); + } else { + throw new RuntimeException(("Illegal union index for 'F19': "+ unionIndex19)); + } + } + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(20, null); + } else { + if (unionIndex20 == 1) { + Utf8 charSequence20; + Object oldString20 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(20); + if (oldString20 instanceof Utf8) { + charSequence20 = (decoder).readString(((Utf8) oldString20)); + } else { + charSequence20 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(20, charSequence20); + } else { + throw new RuntimeException(("Illegal union index for 'F20': "+ unionIndex20)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(21, null); + } else { + if (unionIndex21 == 1) { + Utf8 charSequence21; + Object oldString21 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(21); + if (oldString21 instanceof Utf8) { + charSequence21 = (decoder).readString(((Utf8) oldString21)); + } else { + charSequence21 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(21, charSequence21); + } else { + throw new RuntimeException(("Illegal union index for 'F21': "+ unionIndex21)); + } + } + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(22, null); + } else { + if (unionIndex22 == 1) { + Utf8 charSequence22; + Object oldString22 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(22); + if (oldString22 instanceof Utf8) { + charSequence22 = (decoder).readString(((Utf8) oldString22)); + } else { + charSequence22 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(22, charSequence22); + } else { + throw new RuntimeException(("Illegal union index for 'F22': "+ unionIndex22)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(23, null); + } else { + if (unionIndex23 == 1) { + Utf8 charSequence23; + Object oldString23 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(23); + if (oldString23 instanceof Utf8) { + charSequence23 = (decoder).readString(((Utf8) oldString23)); + } else { + charSequence23 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(23, charSequence23); + } else { + throw new RuntimeException(("Illegal union index for 'F23': "+ unionIndex23)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(24, null); + } else { + if (unionIndex24 == 1) { + Utf8 charSequence24; + Object oldString24 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(24); + if (oldString24 instanceof Utf8) { + charSequence24 = (decoder).readString(((Utf8) oldString24)); + } else { + charSequence24 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(24, charSequence24); + } else { + throw new RuntimeException(("Illegal union index for 'F24': "+ unionIndex24)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(25, null); + } else { + if (unionIndex25 == 1) { + Utf8 charSequence25; + Object oldString25 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(25); + if (oldString25 instanceof Utf8) { + charSequence25 = (decoder).readString(((Utf8) oldString25)); + } else { + charSequence25 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(25, charSequence25); + } else { + throw new RuntimeException(("Illegal union index for 'F25': "+ unionIndex25)); + } + } + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(26, null); + } else { + if (unionIndex26 == 1) { + Utf8 charSequence26; + Object oldString26 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(26); + if (oldString26 instanceof Utf8) { + charSequence26 = (decoder).readString(((Utf8) oldString26)); + } else { + charSequence26 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(26, charSequence26); + } else { + throw new RuntimeException(("Illegal union index for 'F26': "+ unionIndex26)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex27 = (decoder.readIndex()); + if (unionIndex27 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(27, null); + } else { + if (unionIndex27 == 1) { + Utf8 charSequence27; + Object oldString27 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(27); + if (oldString27 instanceof Utf8) { + charSequence27 = (decoder).readString(((Utf8) oldString27)); + } else { + charSequence27 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(27, charSequence27); + } else { + throw new RuntimeException(("Illegal union index for 'F27': "+ unionIndex27)); + } + } + int unionIndex28 = (decoder.readIndex()); + if (unionIndex28 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(28, null); + } else { + if (unionIndex28 == 1) { + Utf8 charSequence28; + Object oldString28 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(28); + if (oldString28 instanceof Utf8) { + charSequence28 = (decoder).readString(((Utf8) oldString28)); + } else { + charSequence28 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(28, charSequence28); + } else { + throw new RuntimeException(("Illegal union index for 'F28': "+ unionIndex28)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex29 = (decoder.readIndex()); + if (unionIndex29 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(29, null); + } else { + if (unionIndex29 == 1) { + Utf8 charSequence29; + Object oldString29 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(29); + if (oldString29 instanceof Utf8) { + charSequence29 = (decoder).readString(((Utf8) oldString29)); + } else { + charSequence29 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(29, charSequence29); + } else { + throw new RuntimeException(("Illegal union index for 'F29': "+ unionIndex29)); + } + } + int unionIndex30 = (decoder.readIndex()); + if (unionIndex30 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(30, null); + } else { + if (unionIndex30 == 1) { + Utf8 charSequence30; + Object oldString30 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(30); + if (oldString30 instanceof Utf8) { + charSequence30 = (decoder).readString(((Utf8) oldString30)); + } else { + charSequence30 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(30, charSequence30); + } else { + throw new RuntimeException(("Illegal union index for 'F30': "+ unionIndex30)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex31 = (decoder.readIndex()); + if (unionIndex31 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(31, null); + } else { + if (unionIndex31 == 1) { + Utf8 charSequence31; + Object oldString31 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(31); + if (oldString31 instanceof Utf8) { + charSequence31 = (decoder).readString(((Utf8) oldString31)); + } else { + charSequence31 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(31, charSequence31); + } else { + throw new RuntimeException(("Illegal union index for 'F31': "+ unionIndex31)); + } + } + int unionIndex32 = (decoder.readIndex()); + if (unionIndex32 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(32, null); + } else { + if (unionIndex32 == 1) { + Utf8 charSequence32; + Object oldString32 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(32); + if (oldString32 instanceof Utf8) { + charSequence32 = (decoder).readString(((Utf8) oldString32)); + } else { + charSequence32 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(32, charSequence32); + } else { + throw new RuntimeException(("Illegal union index for 'F32': "+ unionIndex32)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex33 = (decoder.readIndex()); + if (unionIndex33 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(33, null); + } else { + if (unionIndex33 == 1) { + Utf8 charSequence33; + Object oldString33 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(33); + if (oldString33 instanceof Utf8) { + charSequence33 = (decoder).readString(((Utf8) oldString33)); + } else { + charSequence33 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(33, charSequence33); + } else { + throw new RuntimeException(("Illegal union index for 'F33': "+ unionIndex33)); + } + } + int unionIndex34 = (decoder.readIndex()); + if (unionIndex34 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(34, null); + } else { + if (unionIndex34 == 1) { + Utf8 charSequence34; + Object oldString34 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(34); + if (oldString34 instanceof Utf8) { + charSequence34 = (decoder).readString(((Utf8) oldString34)); + } else { + charSequence34 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(34, charSequence34); + } else { + throw new RuntimeException(("Illegal union index for 'F34': "+ unionIndex34)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex35 = (decoder.readIndex()); + if (unionIndex35 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(35, null); + } else { + if (unionIndex35 == 1) { + Utf8 charSequence35; + Object oldString35 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(35); + if (oldString35 instanceof Utf8) { + charSequence35 = (decoder).readString(((Utf8) oldString35)); + } else { + charSequence35 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(35, charSequence35); + } else { + throw new RuntimeException(("Illegal union index for 'F35': "+ unionIndex35)); + } + } + int unionIndex36 = (decoder.readIndex()); + if (unionIndex36 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(36, null); + } else { + if (unionIndex36 == 1) { + Utf8 charSequence36; + Object oldString36 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(36); + if (oldString36 instanceof Utf8) { + charSequence36 = (decoder).readString(((Utf8) oldString36)); + } else { + charSequence36 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(36, charSequence36); + } else { + throw new RuntimeException(("Illegal union index for 'F36': "+ unionIndex36)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex37 = (decoder.readIndex()); + if (unionIndex37 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(37, null); + } else { + if (unionIndex37 == 1) { + Utf8 charSequence37; + Object oldString37 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(37); + if (oldString37 instanceof Utf8) { + charSequence37 = (decoder).readString(((Utf8) oldString37)); + } else { + charSequence37 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(37, charSequence37); + } else { + throw new RuntimeException(("Illegal union index for 'F37': "+ unionIndex37)); + } + } + int unionIndex38 = (decoder.readIndex()); + if (unionIndex38 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(38, null); + } else { + if (unionIndex38 == 1) { + Utf8 charSequence38; + Object oldString38 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(38); + if (oldString38 instanceof Utf8) { + charSequence38 = (decoder).readString(((Utf8) oldString38)); + } else { + charSequence38 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(38, charSequence38); + } else { + throw new RuntimeException(("Illegal union index for 'F38': "+ unionIndex38)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex39 = (decoder.readIndex()); + if (unionIndex39 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(39, null); + } else { + if (unionIndex39 == 1) { + Utf8 charSequence39; + Object oldString39 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(39); + if (oldString39 instanceof Utf8) { + charSequence39 = (decoder).readString(((Utf8) oldString39)); + } else { + charSequence39 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(39, charSequence39); + } else { + throw new RuntimeException(("Illegal union index for 'F39': "+ unionIndex39)); + } + } + int unionIndex40 = (decoder.readIndex()); + if (unionIndex40 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(40, null); + } else { + if (unionIndex40 == 1) { + Utf8 charSequence40; + Object oldString40 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(40); + if (oldString40 instanceof Utf8) { + charSequence40 = (decoder).readString(((Utf8) oldString40)); + } else { + charSequence40 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(40, charSequence40); + } else { + throw new RuntimeException(("Illegal union index for 'F40': "+ unionIndex40)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex41 = (decoder.readIndex()); + if (unionIndex41 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(41, null); + } else { + if (unionIndex41 == 1) { + Utf8 charSequence41; + Object oldString41 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(41); + if (oldString41 instanceof Utf8) { + charSequence41 = (decoder).readString(((Utf8) oldString41)); + } else { + charSequence41 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(41, charSequence41); + } else { + throw new RuntimeException(("Illegal union index for 'F41': "+ unionIndex41)); + } + } + int unionIndex42 = (decoder.readIndex()); + if (unionIndex42 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(42, null); + } else { + if (unionIndex42 == 1) { + Utf8 charSequence42; + Object oldString42 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(42); + if (oldString42 instanceof Utf8) { + charSequence42 = (decoder).readString(((Utf8) oldString42)); + } else { + charSequence42 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(42, charSequence42); + } else { + throw new RuntimeException(("Illegal union index for 'F42': "+ unionIndex42)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex43 = (decoder.readIndex()); + if (unionIndex43 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(43, null); + } else { + if (unionIndex43 == 1) { + Utf8 charSequence43; + Object oldString43 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(43); + if (oldString43 instanceof Utf8) { + charSequence43 = (decoder).readString(((Utf8) oldString43)); + } else { + charSequence43 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(43, charSequence43); + } else { + throw new RuntimeException(("Illegal union index for 'F43': "+ unionIndex43)); + } + } + int unionIndex44 = (decoder.readIndex()); + if (unionIndex44 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(44, null); + } else { + if (unionIndex44 == 1) { + Utf8 charSequence44; + Object oldString44 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(44); + if (oldString44 instanceof Utf8) { + charSequence44 = (decoder).readString(((Utf8) oldString44)); + } else { + charSequence44 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(44, charSequence44); + } else { + throw new RuntimeException(("Illegal union index for 'F44': "+ unionIndex44)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex45 = (decoder.readIndex()); + if (unionIndex45 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(45, null); + } else { + if (unionIndex45 == 1) { + Utf8 charSequence45; + Object oldString45 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(45); + if (oldString45 instanceof Utf8) { + charSequence45 = (decoder).readString(((Utf8) oldString45)); + } else { + charSequence45 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(45, charSequence45); + } else { + throw new RuntimeException(("Illegal union index for 'F45': "+ unionIndex45)); + } + } + int unionIndex46 = (decoder.readIndex()); + if (unionIndex46 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(46, null); + } else { + if (unionIndex46 == 1) { + Utf8 charSequence46; + Object oldString46 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(46); + if (oldString46 instanceof Utf8) { + charSequence46 = (decoder).readString(((Utf8) oldString46)); + } else { + charSequence46 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(46, charSequence46); + } else { + throw new RuntimeException(("Illegal union index for 'F46': "+ unionIndex46)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex47 = (decoder.readIndex()); + if (unionIndex47 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(47, null); + } else { + if (unionIndex47 == 1) { + Utf8 charSequence47; + Object oldString47 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(47); + if (oldString47 instanceof Utf8) { + charSequence47 = (decoder).readString(((Utf8) oldString47)); + } else { + charSequence47 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(47, charSequence47); + } else { + throw new RuntimeException(("Illegal union index for 'F47': "+ unionIndex47)); + } + } + int unionIndex48 = (decoder.readIndex()); + if (unionIndex48 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(48, null); + } else { + if (unionIndex48 == 1) { + Utf8 charSequence48; + Object oldString48 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(48); + if (oldString48 instanceof Utf8) { + charSequence48 = (decoder).readString(((Utf8) oldString48)); + } else { + charSequence48 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(48, charSequence48); + } else { + throw new RuntimeException(("Illegal union index for 'F48': "+ unionIndex48)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex49 = (decoder.readIndex()); + if (unionIndex49 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(49, null); + } else { + if (unionIndex49 == 1) { + Utf8 charSequence49; + Object oldString49 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(49); + if (oldString49 instanceof Utf8) { + charSequence49 = (decoder).readString(((Utf8) oldString49)); + } else { + charSequence49 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(49, charSequence49); + } else { + throw new RuntimeException(("Illegal union index for 'F49': "+ unionIndex49)); + } + } + int unionIndex50 = (decoder.readIndex()); + if (unionIndex50 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(50, null); + } else { + if (unionIndex50 == 1) { + Utf8 charSequence50; + Object oldString50 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(50); + if (oldString50 instanceof Utf8) { + charSequence50 = (decoder).readString(((Utf8) oldString50)); + } else { + charSequence50 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(50, charSequence50); + } else { + throw new RuntimeException(("Illegal union index for 'F50': "+ unionIndex50)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex51 = (decoder.readIndex()); + if (unionIndex51 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(51, null); + } else { + if (unionIndex51 == 1) { + Utf8 charSequence51; + Object oldString51 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(51); + if (oldString51 instanceof Utf8) { + charSequence51 = (decoder).readString(((Utf8) oldString51)); + } else { + charSequence51 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(51, charSequence51); + } else { + throw new RuntimeException(("Illegal union index for 'F51': "+ unionIndex51)); + } + } + int unionIndex52 = (decoder.readIndex()); + if (unionIndex52 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(52, null); + } else { + if (unionIndex52 == 1) { + Utf8 charSequence52; + Object oldString52 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(52); + if (oldString52 instanceof Utf8) { + charSequence52 = (decoder).readString(((Utf8) oldString52)); + } else { + charSequence52 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(52, charSequence52); + } else { + throw new RuntimeException(("Illegal union index for 'F52': "+ unionIndex52)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex53 = (decoder.readIndex()); + if (unionIndex53 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(53, null); + } else { + if (unionIndex53 == 1) { + Utf8 charSequence53; + Object oldString53 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(53); + if (oldString53 instanceof Utf8) { + charSequence53 = (decoder).readString(((Utf8) oldString53)); + } else { + charSequence53 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(53, charSequence53); + } else { + throw new RuntimeException(("Illegal union index for 'F53': "+ unionIndex53)); + } + } + int unionIndex54 = (decoder.readIndex()); + if (unionIndex54 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(54, null); + } else { + if (unionIndex54 == 1) { + Utf8 charSequence54; + Object oldString54 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(54); + if (oldString54 instanceof Utf8) { + charSequence54 = (decoder).readString(((Utf8) oldString54)); + } else { + charSequence54 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(54, charSequence54); + } else { + throw new RuntimeException(("Illegal union index for 'F54': "+ unionIndex54)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex55 = (decoder.readIndex()); + if (unionIndex55 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(55, null); + } else { + if (unionIndex55 == 1) { + Utf8 charSequence55; + Object oldString55 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(55); + if (oldString55 instanceof Utf8) { + charSequence55 = (decoder).readString(((Utf8) oldString55)); + } else { + charSequence55 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(55, charSequence55); + } else { + throw new RuntimeException(("Illegal union index for 'F55': "+ unionIndex55)); + } + } + int unionIndex56 = (decoder.readIndex()); + if (unionIndex56 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(56, null); + } else { + if (unionIndex56 == 1) { + Utf8 charSequence56; + Object oldString56 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(56); + if (oldString56 instanceof Utf8) { + charSequence56 = (decoder).readString(((Utf8) oldString56)); + } else { + charSequence56 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(56, charSequence56); + } else { + throw new RuntimeException(("Illegal union index for 'F56': "+ unionIndex56)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex57 = (decoder.readIndex()); + if (unionIndex57 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(57, null); + } else { + if (unionIndex57 == 1) { + Utf8 charSequence57; + Object oldString57 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(57); + if (oldString57 instanceof Utf8) { + charSequence57 = (decoder).readString(((Utf8) oldString57)); + } else { + charSequence57 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(57, charSequence57); + } else { + throw new RuntimeException(("Illegal union index for 'F57': "+ unionIndex57)); + } + } + int unionIndex58 = (decoder.readIndex()); + if (unionIndex58 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(58, null); + } else { + if (unionIndex58 == 1) { + Utf8 charSequence58; + Object oldString58 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(58); + if (oldString58 instanceof Utf8) { + charSequence58 = (decoder).readString(((Utf8) oldString58)); + } else { + charSequence58 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(58, charSequence58); + } else { + throw new RuntimeException(("Illegal union index for 'F58': "+ unionIndex58)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex59 = (decoder.readIndex()); + if (unionIndex59 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(59, null); + } else { + if (unionIndex59 == 1) { + Utf8 charSequence59; + Object oldString59 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(59); + if (oldString59 instanceof Utf8) { + charSequence59 = (decoder).readString(((Utf8) oldString59)); + } else { + charSequence59 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(59, charSequence59); + } else { + throw new RuntimeException(("Illegal union index for 'F59': "+ unionIndex59)); + } + } + int unionIndex60 = (decoder.readIndex()); + if (unionIndex60 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(60, null); + } else { + if (unionIndex60 == 1) { + Utf8 charSequence60; + Object oldString60 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(60); + if (oldString60 instanceof Utf8) { + charSequence60 = (decoder).readString(((Utf8) oldString60)); + } else { + charSequence60 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(60, charSequence60); + } else { + throw new RuntimeException(("Illegal union index for 'F60': "+ unionIndex60)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex61 = (decoder.readIndex()); + if (unionIndex61 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(61, null); + } else { + if (unionIndex61 == 1) { + Utf8 charSequence61; + Object oldString61 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(61); + if (oldString61 instanceof Utf8) { + charSequence61 = (decoder).readString(((Utf8) oldString61)); + } else { + charSequence61 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(61, charSequence61); + } else { + throw new RuntimeException(("Illegal union index for 'F61': "+ unionIndex61)); + } + } + int unionIndex62 = (decoder.readIndex()); + if (unionIndex62 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(62, null); + } else { + if (unionIndex62 == 1) { + Utf8 charSequence62; + Object oldString62 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(62); + if (oldString62 instanceof Utf8) { + charSequence62 = (decoder).readString(((Utf8) oldString62)); + } else { + charSequence62 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(62, charSequence62); + } else { + throw new RuntimeException(("Illegal union index for 'F62': "+ unionIndex62)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex63 = (decoder.readIndex()); + if (unionIndex63 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(63, null); + } else { + if (unionIndex63 == 1) { + Utf8 charSequence63; + Object oldString63 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(63); + if (oldString63 instanceof Utf8) { + charSequence63 = (decoder).readString(((Utf8) oldString63)); + } else { + charSequence63 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(63, charSequence63); + } else { + throw new RuntimeException(("Illegal union index for 'F63': "+ unionIndex63)); + } + } + int unionIndex64 = (decoder.readIndex()); + if (unionIndex64 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(64, null); + } else { + if (unionIndex64 == 1) { + Utf8 charSequence64; + Object oldString64 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(64); + if (oldString64 instanceof Utf8) { + charSequence64 = (decoder).readString(((Utf8) oldString64)); + } else { + charSequence64 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(64, charSequence64); + } else { + throw new RuntimeException(("Illegal union index for 'F64': "+ unionIndex64)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex65 = (decoder.readIndex()); + if (unionIndex65 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(65, null); + } else { + if (unionIndex65 == 1) { + Utf8 charSequence65; + Object oldString65 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(65); + if (oldString65 instanceof Utf8) { + charSequence65 = (decoder).readString(((Utf8) oldString65)); + } else { + charSequence65 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(65, charSequence65); + } else { + throw new RuntimeException(("Illegal union index for 'F65': "+ unionIndex65)); + } + } + int unionIndex66 = (decoder.readIndex()); + if (unionIndex66 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(66, null); + } else { + if (unionIndex66 == 1) { + Utf8 charSequence66; + Object oldString66 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(66); + if (oldString66 instanceof Utf8) { + charSequence66 = (decoder).readString(((Utf8) oldString66)); + } else { + charSequence66 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(66, charSequence66); + } else { + throw new RuntimeException(("Illegal union index for 'F66': "+ unionIndex66)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex67 = (decoder.readIndex()); + if (unionIndex67 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(67, null); + } else { + if (unionIndex67 == 1) { + Utf8 charSequence67; + Object oldString67 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(67); + if (oldString67 instanceof Utf8) { + charSequence67 = (decoder).readString(((Utf8) oldString67)); + } else { + charSequence67 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(67, charSequence67); + } else { + throw new RuntimeException(("Illegal union index for 'F67': "+ unionIndex67)); + } + } + int unionIndex68 = (decoder.readIndex()); + if (unionIndex68 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(68, null); + } else { + if (unionIndex68 == 1) { + Utf8 charSequence68; + Object oldString68 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(68); + if (oldString68 instanceof Utf8) { + charSequence68 = (decoder).readString(((Utf8) oldString68)); + } else { + charSequence68 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(68, charSequence68); + } else { + throw new RuntimeException(("Illegal union index for 'F68': "+ unionIndex68)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex69 = (decoder.readIndex()); + if (unionIndex69 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(69, null); + } else { + if (unionIndex69 == 1) { + Utf8 charSequence69; + Object oldString69 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(69); + if (oldString69 instanceof Utf8) { + charSequence69 = (decoder).readString(((Utf8) oldString69)); + } else { + charSequence69 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(69, charSequence69); + } else { + throw new RuntimeException(("Illegal union index for 'F69': "+ unionIndex69)); + } + } + int unionIndex70 = (decoder.readIndex()); + if (unionIndex70 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(70, null); + } else { + if (unionIndex70 == 1) { + Utf8 charSequence70; + Object oldString70 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(70); + if (oldString70 instanceof Utf8) { + charSequence70 = (decoder).readString(((Utf8) oldString70)); + } else { + charSequence70 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(70, charSequence70); + } else { + throw new RuntimeException(("Illegal union index for 'F70': "+ unionIndex70)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex71 = (decoder.readIndex()); + if (unionIndex71 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(71, null); + } else { + if (unionIndex71 == 1) { + Utf8 charSequence71; + Object oldString71 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(71); + if (oldString71 instanceof Utf8) { + charSequence71 = (decoder).readString(((Utf8) oldString71)); + } else { + charSequence71 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(71, charSequence71); + } else { + throw new RuntimeException(("Illegal union index for 'F71': "+ unionIndex71)); + } + } + int unionIndex72 = (decoder.readIndex()); + if (unionIndex72 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(72, null); + } else { + if (unionIndex72 == 1) { + Utf8 charSequence72; + Object oldString72 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(72); + if (oldString72 instanceof Utf8) { + charSequence72 = (decoder).readString(((Utf8) oldString72)); + } else { + charSequence72 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(72, charSequence72); + } else { + throw new RuntimeException(("Illegal union index for 'F72': "+ unionIndex72)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex73 = (decoder.readIndex()); + if (unionIndex73 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(73, null); + } else { + if (unionIndex73 == 1) { + Utf8 charSequence73; + Object oldString73 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(73); + if (oldString73 instanceof Utf8) { + charSequence73 = (decoder).readString(((Utf8) oldString73)); + } else { + charSequence73 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(73, charSequence73); + } else { + throw new RuntimeException(("Illegal union index for 'F73': "+ unionIndex73)); + } + } + int unionIndex74 = (decoder.readIndex()); + if (unionIndex74 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(74, null); + } else { + if (unionIndex74 == 1) { + Utf8 charSequence74; + Object oldString74 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(74); + if (oldString74 instanceof Utf8) { + charSequence74 = (decoder).readString(((Utf8) oldString74)); + } else { + charSequence74 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(74, charSequence74); + } else { + throw new RuntimeException(("Illegal union index for 'F74': "+ unionIndex74)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex75 = (decoder.readIndex()); + if (unionIndex75 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(75, null); + } else { + if (unionIndex75 == 1) { + Utf8 charSequence75; + Object oldString75 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(75); + if (oldString75 instanceof Utf8) { + charSequence75 = (decoder).readString(((Utf8) oldString75)); + } else { + charSequence75 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(75, charSequence75); + } else { + throw new RuntimeException(("Illegal union index for 'F75': "+ unionIndex75)); + } + } + int unionIndex76 = (decoder.readIndex()); + if (unionIndex76 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(76, null); + } else { + if (unionIndex76 == 1) { + Utf8 charSequence76; + Object oldString76 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(76); + if (oldString76 instanceof Utf8) { + charSequence76 = (decoder).readString(((Utf8) oldString76)); + } else { + charSequence76 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(76, charSequence76); + } else { + throw new RuntimeException(("Illegal union index for 'F76': "+ unionIndex76)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex77 = (decoder.readIndex()); + if (unionIndex77 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(77, null); + } else { + if (unionIndex77 == 1) { + Utf8 charSequence77; + Object oldString77 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(77); + if (oldString77 instanceof Utf8) { + charSequence77 = (decoder).readString(((Utf8) oldString77)); + } else { + charSequence77 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(77, charSequence77); + } else { + throw new RuntimeException(("Illegal union index for 'F77': "+ unionIndex77)); + } + } + int unionIndex78 = (decoder.readIndex()); + if (unionIndex78 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(78, null); + } else { + if (unionIndex78 == 1) { + Utf8 charSequence78; + Object oldString78 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(78); + if (oldString78 instanceof Utf8) { + charSequence78 = (decoder).readString(((Utf8) oldString78)); + } else { + charSequence78 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(78, charSequence78); + } else { + throw new RuntimeException(("Illegal union index for 'F78': "+ unionIndex78)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex79 = (decoder.readIndex()); + if (unionIndex79 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(79, null); + } else { + if (unionIndex79 == 1) { + Utf8 charSequence79; + Object oldString79 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(79); + if (oldString79 instanceof Utf8) { + charSequence79 = (decoder).readString(((Utf8) oldString79)); + } else { + charSequence79 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(79, charSequence79); + } else { + throw new RuntimeException(("Illegal union index for 'F79': "+ unionIndex79)); + } + } + int unionIndex80 = (decoder.readIndex()); + if (unionIndex80 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(80, null); + } else { + if (unionIndex80 == 1) { + Utf8 charSequence80; + Object oldString80 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(80); + if (oldString80 instanceof Utf8) { + charSequence80 = (decoder).readString(((Utf8) oldString80)); + } else { + charSequence80 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(80, charSequence80); + } else { + throw new RuntimeException(("Illegal union index for 'F80': "+ unionIndex80)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex81 = (decoder.readIndex()); + if (unionIndex81 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(81, null); + } else { + if (unionIndex81 == 1) { + Utf8 charSequence81; + Object oldString81 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(81); + if (oldString81 instanceof Utf8) { + charSequence81 = (decoder).readString(((Utf8) oldString81)); + } else { + charSequence81 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(81, charSequence81); + } else { + throw new RuntimeException(("Illegal union index for 'F81': "+ unionIndex81)); + } + } + int unionIndex82 = (decoder.readIndex()); + if (unionIndex82 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(82, null); + } else { + if (unionIndex82 == 1) { + Utf8 charSequence82; + Object oldString82 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(82); + if (oldString82 instanceof Utf8) { + charSequence82 = (decoder).readString(((Utf8) oldString82)); + } else { + charSequence82 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(82, charSequence82); + } else { + throw new RuntimeException(("Illegal union index for 'F82': "+ unionIndex82)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex83 = (decoder.readIndex()); + if (unionIndex83 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(83, null); + } else { + if (unionIndex83 == 1) { + Utf8 charSequence83; + Object oldString83 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(83); + if (oldString83 instanceof Utf8) { + charSequence83 = (decoder).readString(((Utf8) oldString83)); + } else { + charSequence83 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(83, charSequence83); + } else { + throw new RuntimeException(("Illegal union index for 'F83': "+ unionIndex83)); + } + } + int unionIndex84 = (decoder.readIndex()); + if (unionIndex84 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(84, null); + } else { + if (unionIndex84 == 1) { + Utf8 charSequence84; + Object oldString84 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(84); + if (oldString84 instanceof Utf8) { + charSequence84 = (decoder).readString(((Utf8) oldString84)); + } else { + charSequence84 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(84, charSequence84); + } else { + throw new RuntimeException(("Illegal union index for 'F84': "+ unionIndex84)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex85 = (decoder.readIndex()); + if (unionIndex85 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(85, null); + } else { + if (unionIndex85 == 1) { + Utf8 charSequence85; + Object oldString85 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(85); + if (oldString85 instanceof Utf8) { + charSequence85 = (decoder).readString(((Utf8) oldString85)); + } else { + charSequence85 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(85, charSequence85); + } else { + throw new RuntimeException(("Illegal union index for 'F85': "+ unionIndex85)); + } + } + int unionIndex86 = (decoder.readIndex()); + if (unionIndex86 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(86, null); + } else { + if (unionIndex86 == 1) { + Utf8 charSequence86; + Object oldString86 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(86); + if (oldString86 instanceof Utf8) { + charSequence86 = (decoder).readString(((Utf8) oldString86)); + } else { + charSequence86 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(86, charSequence86); + } else { + throw new RuntimeException(("Illegal union index for 'F86': "+ unionIndex86)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex87 = (decoder.readIndex()); + if (unionIndex87 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(87, null); + } else { + if (unionIndex87 == 1) { + Utf8 charSequence87; + Object oldString87 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(87); + if (oldString87 instanceof Utf8) { + charSequence87 = (decoder).readString(((Utf8) oldString87)); + } else { + charSequence87 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(87, charSequence87); + } else { + throw new RuntimeException(("Illegal union index for 'F87': "+ unionIndex87)); + } + } + int unionIndex88 = (decoder.readIndex()); + if (unionIndex88 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(88, null); + } else { + if (unionIndex88 == 1) { + Utf8 charSequence88; + Object oldString88 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(88); + if (oldString88 instanceof Utf8) { + charSequence88 = (decoder).readString(((Utf8) oldString88)); + } else { + charSequence88 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(88, charSequence88); + } else { + throw new RuntimeException(("Illegal union index for 'F88': "+ unionIndex88)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex89 = (decoder.readIndex()); + if (unionIndex89 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(89, null); + } else { + if (unionIndex89 == 1) { + Utf8 charSequence89; + Object oldString89 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(89); + if (oldString89 instanceof Utf8) { + charSequence89 = (decoder).readString(((Utf8) oldString89)); + } else { + charSequence89 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(89, charSequence89); + } else { + throw new RuntimeException(("Illegal union index for 'F89': "+ unionIndex89)); + } + } + int unionIndex90 = (decoder.readIndex()); + if (unionIndex90 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(90, null); + } else { + if (unionIndex90 == 1) { + Utf8 charSequence90; + Object oldString90 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(90); + if (oldString90 instanceof Utf8) { + charSequence90 = (decoder).readString(((Utf8) oldString90)); + } else { + charSequence90 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(90, charSequence90); + } else { + throw new RuntimeException(("Illegal union index for 'F90': "+ unionIndex90)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex91 = (decoder.readIndex()); + if (unionIndex91 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(91, null); + } else { + if (unionIndex91 == 1) { + Utf8 charSequence91; + Object oldString91 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(91); + if (oldString91 instanceof Utf8) { + charSequence91 = (decoder).readString(((Utf8) oldString91)); + } else { + charSequence91 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(91, charSequence91); + } else { + throw new RuntimeException(("Illegal union index for 'F91': "+ unionIndex91)); + } + } + int unionIndex92 = (decoder.readIndex()); + if (unionIndex92 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(92, null); + } else { + if (unionIndex92 == 1) { + Utf8 charSequence92; + Object oldString92 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(92); + if (oldString92 instanceof Utf8) { + charSequence92 = (decoder).readString(((Utf8) oldString92)); + } else { + charSequence92 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(92, charSequence92); + } else { + throw new RuntimeException(("Illegal union index for 'F92': "+ unionIndex92)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex93 = (decoder.readIndex()); + if (unionIndex93 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(93, null); + } else { + if (unionIndex93 == 1) { + Utf8 charSequence93; + Object oldString93 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(93); + if (oldString93 instanceof Utf8) { + charSequence93 = (decoder).readString(((Utf8) oldString93)); + } else { + charSequence93 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(93, charSequence93); + } else { + throw new RuntimeException(("Illegal union index for 'F93': "+ unionIndex93)); + } + } + int unionIndex94 = (decoder.readIndex()); + if (unionIndex94 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(94, null); + } else { + if (unionIndex94 == 1) { + Utf8 charSequence94; + Object oldString94 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(94); + if (oldString94 instanceof Utf8) { + charSequence94 = (decoder).readString(((Utf8) oldString94)); + } else { + charSequence94 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(94, charSequence94); + } else { + throw new RuntimeException(("Illegal union index for 'F94': "+ unionIndex94)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex95 = (decoder.readIndex()); + if (unionIndex95 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(95, null); + } else { + if (unionIndex95 == 1) { + Utf8 charSequence95; + Object oldString95 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(95); + if (oldString95 instanceof Utf8) { + charSequence95 = (decoder).readString(((Utf8) oldString95)); + } else { + charSequence95 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(95, charSequence95); + } else { + throw new RuntimeException(("Illegal union index for 'F95': "+ unionIndex95)); + } + } + int unionIndex96 = (decoder.readIndex()); + if (unionIndex96 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(96, null); + } else { + if (unionIndex96 == 1) { + Utf8 charSequence96; + Object oldString96 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(96); + if (oldString96 instanceof Utf8) { + charSequence96 = (decoder).readString(((Utf8) oldString96)); + } else { + charSequence96 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(96, charSequence96); + } else { + throw new RuntimeException(("Illegal union index for 'F96': "+ unionIndex96)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex97 = (decoder.readIndex()); + if (unionIndex97 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(97, null); + } else { + if (unionIndex97 == 1) { + Utf8 charSequence97; + Object oldString97 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(97); + if (oldString97 instanceof Utf8) { + charSequence97 = (decoder).readString(((Utf8) oldString97)); + } else { + charSequence97 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(97, charSequence97); + } else { + throw new RuntimeException(("Illegal union index for 'F97': "+ unionIndex97)); + } + } + int unionIndex98 = (decoder.readIndex()); + if (unionIndex98 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(98, null); + } else { + if (unionIndex98 == 1) { + Utf8 charSequence98; + Object oldString98 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(98); + if (oldString98 instanceof Utf8) { + charSequence98 = (decoder).readString(((Utf8) oldString98)); + } else { + charSequence98 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(98, charSequence98); + } else { + throw new RuntimeException(("Illegal union index for 'F98': "+ unionIndex98)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex99 = (decoder.readIndex()); + if (unionIndex99 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(99, null); + } else { + if (unionIndex99 == 1) { + Utf8 charSequence99; + Object oldString99 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(99); + if (oldString99 instanceof Utf8) { + charSequence99 = (decoder).readString(((Utf8) oldString99)); + } else { + charSequence99 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(99, charSequence99); + } else { + throw new RuntimeException(("Illegal union index for 'F99': "+ unionIndex99)); + } + } + int unionIndex100 = (decoder.readIndex()); + if (unionIndex100 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(100, null); + } else { + if (unionIndex100 == 1) { + Utf8 charSequence100; + Object oldString100 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(100); + if (oldString100 instanceof Utf8) { + charSequence100 = (decoder).readString(((Utf8) oldString100)); + } else { + charSequence100 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(100, charSequence100); + } else { + throw new RuntimeException(("Illegal union index for 'F100': "+ unionIndex100)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex101 = (decoder.readIndex()); + if (unionIndex101 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(101, null); + } else { + if (unionIndex101 == 1) { + Utf8 charSequence101; + Object oldString101 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(101); + if (oldString101 instanceof Utf8) { + charSequence101 = (decoder).readString(((Utf8) oldString101)); + } else { + charSequence101 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(101, charSequence101); + } else { + throw new RuntimeException(("Illegal union index for 'F101': "+ unionIndex101)); + } + } + int unionIndex102 = (decoder.readIndex()); + if (unionIndex102 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(102, null); + } else { + if (unionIndex102 == 1) { + Utf8 charSequence102; + Object oldString102 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(102); + if (oldString102 instanceof Utf8) { + charSequence102 = (decoder).readString(((Utf8) oldString102)); + } else { + charSequence102 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(102, charSequence102); + } else { + throw new RuntimeException(("Illegal union index for 'F102': "+ unionIndex102)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex103 = (decoder.readIndex()); + if (unionIndex103 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(103, null); + } else { + if (unionIndex103 == 1) { + Utf8 charSequence103; + Object oldString103 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(103); + if (oldString103 instanceof Utf8) { + charSequence103 = (decoder).readString(((Utf8) oldString103)); + } else { + charSequence103 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(103, charSequence103); + } else { + throw new RuntimeException(("Illegal union index for 'F103': "+ unionIndex103)); + } + } + int unionIndex104 = (decoder.readIndex()); + if (unionIndex104 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(104, null); + } else { + if (unionIndex104 == 1) { + Utf8 charSequence104; + Object oldString104 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(104); + if (oldString104 instanceof Utf8) { + charSequence104 = (decoder).readString(((Utf8) oldString104)); + } else { + charSequence104 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(104, charSequence104); + } else { + throw new RuntimeException(("Illegal union index for 'F104': "+ unionIndex104)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex105 = (decoder.readIndex()); + if (unionIndex105 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(105, null); + } else { + if (unionIndex105 == 1) { + Utf8 charSequence105; + Object oldString105 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(105); + if (oldString105 instanceof Utf8) { + charSequence105 = (decoder).readString(((Utf8) oldString105)); + } else { + charSequence105 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(105, charSequence105); + } else { + throw new RuntimeException(("Illegal union index for 'F105': "+ unionIndex105)); + } + } + int unionIndex106 = (decoder.readIndex()); + if (unionIndex106 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(106, null); + } else { + if (unionIndex106 == 1) { + Utf8 charSequence106; + Object oldString106 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(106); + if (oldString106 instanceof Utf8) { + charSequence106 = (decoder).readString(((Utf8) oldString106)); + } else { + charSequence106 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(106, charSequence106); + } else { + throw new RuntimeException(("Illegal union index for 'F106': "+ unionIndex106)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex107 = (decoder.readIndex()); + if (unionIndex107 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(107, null); + } else { + if (unionIndex107 == 1) { + Utf8 charSequence107; + Object oldString107 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(107); + if (oldString107 instanceof Utf8) { + charSequence107 = (decoder).readString(((Utf8) oldString107)); + } else { + charSequence107 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(107, charSequence107); + } else { + throw new RuntimeException(("Illegal union index for 'F107': "+ unionIndex107)); + } + } + int unionIndex108 = (decoder.readIndex()); + if (unionIndex108 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(108, null); + } else { + if (unionIndex108 == 1) { + Utf8 charSequence108; + Object oldString108 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(108); + if (oldString108 instanceof Utf8) { + charSequence108 = (decoder).readString(((Utf8) oldString108)); + } else { + charSequence108 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(108, charSequence108); + } else { + throw new RuntimeException(("Illegal union index for 'F108': "+ unionIndex108)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex109 = (decoder.readIndex()); + if (unionIndex109 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(109, null); + } else { + if (unionIndex109 == 1) { + Utf8 charSequence109; + Object oldString109 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(109); + if (oldString109 instanceof Utf8) { + charSequence109 = (decoder).readString(((Utf8) oldString109)); + } else { + charSequence109 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(109, charSequence109); + } else { + throw new RuntimeException(("Illegal union index for 'F109': "+ unionIndex109)); + } + } + int unionIndex110 = (decoder.readIndex()); + if (unionIndex110 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(110, null); + } else { + if (unionIndex110 == 1) { + Utf8 charSequence110; + Object oldString110 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(110); + if (oldString110 instanceof Utf8) { + charSequence110 = (decoder).readString(((Utf8) oldString110)); + } else { + charSequence110 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(110, charSequence110); + } else { + throw new RuntimeException(("Illegal union index for 'F110': "+ unionIndex110)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex111 = (decoder.readIndex()); + if (unionIndex111 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(111, null); + } else { + if (unionIndex111 == 1) { + Utf8 charSequence111; + Object oldString111 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(111); + if (oldString111 instanceof Utf8) { + charSequence111 = (decoder).readString(((Utf8) oldString111)); + } else { + charSequence111 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(111, charSequence111); + } else { + throw new RuntimeException(("Illegal union index for 'F111': "+ unionIndex111)); + } + } + int unionIndex112 = (decoder.readIndex()); + if (unionIndex112 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(112, null); + } else { + if (unionIndex112 == 1) { + Utf8 charSequence112; + Object oldString112 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(112); + if (oldString112 instanceof Utf8) { + charSequence112 = (decoder).readString(((Utf8) oldString112)); + } else { + charSequence112 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(112, charSequence112); + } else { + throw new RuntimeException(("Illegal union index for 'F112': "+ unionIndex112)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex113 = (decoder.readIndex()); + if (unionIndex113 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(113, null); + } else { + if (unionIndex113 == 1) { + Utf8 charSequence113; + Object oldString113 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(113); + if (oldString113 instanceof Utf8) { + charSequence113 = (decoder).readString(((Utf8) oldString113)); + } else { + charSequence113 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(113, charSequence113); + } else { + throw new RuntimeException(("Illegal union index for 'F113': "+ unionIndex113)); + } + } + int unionIndex114 = (decoder.readIndex()); + if (unionIndex114 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(114, null); + } else { + if (unionIndex114 == 1) { + Utf8 charSequence114; + Object oldString114 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(114); + if (oldString114 instanceof Utf8) { + charSequence114 = (decoder).readString(((Utf8) oldString114)); + } else { + charSequence114 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(114, charSequence114); + } else { + throw new RuntimeException(("Illegal union index for 'F114': "+ unionIndex114)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex115 = (decoder.readIndex()); + if (unionIndex115 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(115, null); + } else { + if (unionIndex115 == 1) { + Utf8 charSequence115; + Object oldString115 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(115); + if (oldString115 instanceof Utf8) { + charSequence115 = (decoder).readString(((Utf8) oldString115)); + } else { + charSequence115 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(115, charSequence115); + } else { + throw new RuntimeException(("Illegal union index for 'F115': "+ unionIndex115)); + } + } + int unionIndex116 = (decoder.readIndex()); + if (unionIndex116 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(116, null); + } else { + if (unionIndex116 == 1) { + Utf8 charSequence116; + Object oldString116 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(116); + if (oldString116 instanceof Utf8) { + charSequence116 = (decoder).readString(((Utf8) oldString116)); + } else { + charSequence116 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(116, charSequence116); + } else { + throw new RuntimeException(("Illegal union index for 'F116': "+ unionIndex116)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex117 = (decoder.readIndex()); + if (unionIndex117 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(117, null); + } else { + if (unionIndex117 == 1) { + Utf8 charSequence117; + Object oldString117 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(117); + if (oldString117 instanceof Utf8) { + charSequence117 = (decoder).readString(((Utf8) oldString117)); + } else { + charSequence117 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(117, charSequence117); + } else { + throw new RuntimeException(("Illegal union index for 'F117': "+ unionIndex117)); + } + } + int unionIndex118 = (decoder.readIndex()); + if (unionIndex118 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(118, null); + } else { + if (unionIndex118 == 1) { + Utf8 charSequence118; + Object oldString118 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(118); + if (oldString118 instanceof Utf8) { + charSequence118 = (decoder).readString(((Utf8) oldString118)); + } else { + charSequence118 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(118, charSequence118); + } else { + throw new RuntimeException(("Illegal union index for 'F118': "+ unionIndex118)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex119 = (decoder.readIndex()); + if (unionIndex119 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(119, null); + } else { + if (unionIndex119 == 1) { + Utf8 charSequence119; + Object oldString119 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(119); + if (oldString119 instanceof Utf8) { + charSequence119 = (decoder).readString(((Utf8) oldString119)); + } else { + charSequence119 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(119, charSequence119); + } else { + throw new RuntimeException(("Illegal union index for 'F119': "+ unionIndex119)); + } + } + int unionIndex120 = (decoder.readIndex()); + if (unionIndex120 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(120, null); + } else { + if (unionIndex120 == 1) { + Utf8 charSequence120; + Object oldString120 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(120); + if (oldString120 instanceof Utf8) { + charSequence120 = (decoder).readString(((Utf8) oldString120)); + } else { + charSequence120 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(120, charSequence120); + } else { + throw new RuntimeException(("Illegal union index for 'F120': "+ unionIndex120)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex121 = (decoder.readIndex()); + if (unionIndex121 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(121, null); + } else { + if (unionIndex121 == 1) { + Utf8 charSequence121; + Object oldString121 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(121); + if (oldString121 instanceof Utf8) { + charSequence121 = (decoder).readString(((Utf8) oldString121)); + } else { + charSequence121 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(121, charSequence121); + } else { + throw new RuntimeException(("Illegal union index for 'F121': "+ unionIndex121)); + } + } + int unionIndex122 = (decoder.readIndex()); + if (unionIndex122 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(122, null); + } else { + if (unionIndex122 == 1) { + Utf8 charSequence122; + Object oldString122 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(122); + if (oldString122 instanceof Utf8) { + charSequence122 = (decoder).readString(((Utf8) oldString122)); + } else { + charSequence122 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(122, charSequence122); + } else { + throw new RuntimeException(("Illegal union index for 'F122': "+ unionIndex122)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex123 = (decoder.readIndex()); + if (unionIndex123 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(123, null); + } else { + if (unionIndex123 == 1) { + Utf8 charSequence123; + Object oldString123 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(123); + if (oldString123 instanceof Utf8) { + charSequence123 = (decoder).readString(((Utf8) oldString123)); + } else { + charSequence123 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(123, charSequence123); + } else { + throw new RuntimeException(("Illegal union index for 'F123': "+ unionIndex123)); + } + } + int unionIndex124 = (decoder.readIndex()); + if (unionIndex124 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(124, null); + } else { + if (unionIndex124 == 1) { + Utf8 charSequence124; + Object oldString124 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(124); + if (oldString124 instanceof Utf8) { + charSequence124 = (decoder).readString(((Utf8) oldString124)); + } else { + charSequence124 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(124, charSequence124); + } else { + throw new RuntimeException(("Illegal union index for 'F124': "+ unionIndex124)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex125 = (decoder.readIndex()); + if (unionIndex125 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(125, null); + } else { + if (unionIndex125 == 1) { + Utf8 charSequence125; + Object oldString125 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(125); + if (oldString125 instanceof Utf8) { + charSequence125 = (decoder).readString(((Utf8) oldString125)); + } else { + charSequence125 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(125, charSequence125); + } else { + throw new RuntimeException(("Illegal union index for 'F125': "+ unionIndex125)); + } + } + int unionIndex126 = (decoder.readIndex()); + if (unionIndex126 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(126, null); + } else { + if (unionIndex126 == 1) { + Utf8 charSequence126; + Object oldString126 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(126); + if (oldString126 instanceof Utf8) { + charSequence126 = (decoder).readString(((Utf8) oldString126)); + } else { + charSequence126 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(126, charSequence126); + } else { + throw new RuntimeException(("Illegal union index for 'F126': "+ unionIndex126)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex127 = (decoder.readIndex()); + if (unionIndex127 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(127, null); + } else { + if (unionIndex127 == 1) { + Utf8 charSequence127; + Object oldString127 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(127); + if (oldString127 instanceof Utf8) { + charSequence127 = (decoder).readString(((Utf8) oldString127)); + } else { + charSequence127 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(127, charSequence127); + } else { + throw new RuntimeException(("Illegal union index for 'F127': "+ unionIndex127)); + } + } + int unionIndex128 = (decoder.readIndex()); + if (unionIndex128 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(128, null); + } else { + if (unionIndex128 == 1) { + Utf8 charSequence128; + Object oldString128 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(128); + if (oldString128 instanceof Utf8) { + charSequence128 = (decoder).readString(((Utf8) oldString128)); + } else { + charSequence128 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(128, charSequence128); + } else { + throw new RuntimeException(("Illegal union index for 'F128': "+ unionIndex128)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex129 = (decoder.readIndex()); + if (unionIndex129 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(129, null); + } else { + if (unionIndex129 == 1) { + Utf8 charSequence129; + Object oldString129 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(129); + if (oldString129 instanceof Utf8) { + charSequence129 = (decoder).readString(((Utf8) oldString129)); + } else { + charSequence129 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(129, charSequence129); + } else { + throw new RuntimeException(("Illegal union index for 'F129': "+ unionIndex129)); + } + } + int unionIndex130 = (decoder.readIndex()); + if (unionIndex130 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(130, null); + } else { + if (unionIndex130 == 1) { + Utf8 charSequence130; + Object oldString130 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(130); + if (oldString130 instanceof Utf8) { + charSequence130 = (decoder).readString(((Utf8) oldString130)); + } else { + charSequence130 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(130, charSequence130); + } else { + throw new RuntimeException(("Illegal union index for 'F130': "+ unionIndex130)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex131 = (decoder.readIndex()); + if (unionIndex131 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(131, null); + } else { + if (unionIndex131 == 1) { + Utf8 charSequence131; + Object oldString131 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(131); + if (oldString131 instanceof Utf8) { + charSequence131 = (decoder).readString(((Utf8) oldString131)); + } else { + charSequence131 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(131, charSequence131); + } else { + throw new RuntimeException(("Illegal union index for 'F131': "+ unionIndex131)); + } + } + int unionIndex132 = (decoder.readIndex()); + if (unionIndex132 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(132, null); + } else { + if (unionIndex132 == 1) { + Utf8 charSequence132; + Object oldString132 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(132); + if (oldString132 instanceof Utf8) { + charSequence132 = (decoder).readString(((Utf8) oldString132)); + } else { + charSequence132 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(132, charSequence132); + } else { + throw new RuntimeException(("Illegal union index for 'F132': "+ unionIndex132)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex133 = (decoder.readIndex()); + if (unionIndex133 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(133, null); + } else { + if (unionIndex133 == 1) { + Utf8 charSequence133; + Object oldString133 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(133); + if (oldString133 instanceof Utf8) { + charSequence133 = (decoder).readString(((Utf8) oldString133)); + } else { + charSequence133 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(133, charSequence133); + } else { + throw new RuntimeException(("Illegal union index for 'F133': "+ unionIndex133)); + } + } + int unionIndex134 = (decoder.readIndex()); + if (unionIndex134 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(134, null); + } else { + if (unionIndex134 == 1) { + Utf8 charSequence134; + Object oldString134 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(134); + if (oldString134 instanceof Utf8) { + charSequence134 = (decoder).readString(((Utf8) oldString134)); + } else { + charSequence134 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(134, charSequence134); + } else { + throw new RuntimeException(("Illegal union index for 'F134': "+ unionIndex134)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex135 = (decoder.readIndex()); + if (unionIndex135 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(135, null); + } else { + if (unionIndex135 == 1) { + Utf8 charSequence135; + Object oldString135 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(135); + if (oldString135 instanceof Utf8) { + charSequence135 = (decoder).readString(((Utf8) oldString135)); + } else { + charSequence135 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(135, charSequence135); + } else { + throw new RuntimeException(("Illegal union index for 'F135': "+ unionIndex135)); + } + } + int unionIndex136 = (decoder.readIndex()); + if (unionIndex136 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(136, null); + } else { + if (unionIndex136 == 1) { + Utf8 charSequence136; + Object oldString136 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(136); + if (oldString136 instanceof Utf8) { + charSequence136 = (decoder).readString(((Utf8) oldString136)); + } else { + charSequence136 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(136, charSequence136); + } else { + throw new RuntimeException(("Illegal union index for 'F136': "+ unionIndex136)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex137 = (decoder.readIndex()); + if (unionIndex137 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(137, null); + } else { + if (unionIndex137 == 1) { + Utf8 charSequence137; + Object oldString137 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(137); + if (oldString137 instanceof Utf8) { + charSequence137 = (decoder).readString(((Utf8) oldString137)); + } else { + charSequence137 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(137, charSequence137); + } else { + throw new RuntimeException(("Illegal union index for 'F137': "+ unionIndex137)); + } + } + int unionIndex138 = (decoder.readIndex()); + if (unionIndex138 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(138, null); + } else { + if (unionIndex138 == 1) { + Utf8 charSequence138; + Object oldString138 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(138); + if (oldString138 instanceof Utf8) { + charSequence138 = (decoder).readString(((Utf8) oldString138)); + } else { + charSequence138 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(138, charSequence138); + } else { + throw new RuntimeException(("Illegal union index for 'F138': "+ unionIndex138)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex139 = (decoder.readIndex()); + if (unionIndex139 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(139, null); + } else { + if (unionIndex139 == 1) { + Utf8 charSequence139; + Object oldString139 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(139); + if (oldString139 instanceof Utf8) { + charSequence139 = (decoder).readString(((Utf8) oldString139)); + } else { + charSequence139 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(139, charSequence139); + } else { + throw new RuntimeException(("Illegal union index for 'F139': "+ unionIndex139)); + } + } + int unionIndex140 = (decoder.readIndex()); + if (unionIndex140 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(140, null); + } else { + if (unionIndex140 == 1) { + Utf8 charSequence140; + Object oldString140 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(140); + if (oldString140 instanceof Utf8) { + charSequence140 = (decoder).readString(((Utf8) oldString140)); + } else { + charSequence140 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(140, charSequence140); + } else { + throw new RuntimeException(("Illegal union index for 'F140': "+ unionIndex140)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex141 = (decoder.readIndex()); + if (unionIndex141 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(141, null); + } else { + if (unionIndex141 == 1) { + Utf8 charSequence141; + Object oldString141 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(141); + if (oldString141 instanceof Utf8) { + charSequence141 = (decoder).readString(((Utf8) oldString141)); + } else { + charSequence141 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(141, charSequence141); + } else { + throw new RuntimeException(("Illegal union index for 'F141': "+ unionIndex141)); + } + } + int unionIndex142 = (decoder.readIndex()); + if (unionIndex142 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(142, null); + } else { + if (unionIndex142 == 1) { + Utf8 charSequence142; + Object oldString142 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(142); + if (oldString142 instanceof Utf8) { + charSequence142 = (decoder).readString(((Utf8) oldString142)); + } else { + charSequence142 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(142, charSequence142); + } else { + throw new RuntimeException(("Illegal union index for 'F142': "+ unionIndex142)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex143 = (decoder.readIndex()); + if (unionIndex143 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(143, null); + } else { + if (unionIndex143 == 1) { + Utf8 charSequence143; + Object oldString143 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(143); + if (oldString143 instanceof Utf8) { + charSequence143 = (decoder).readString(((Utf8) oldString143)); + } else { + charSequence143 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(143, charSequence143); + } else { + throw new RuntimeException(("Illegal union index for 'F143': "+ unionIndex143)); + } + } + int unionIndex144 = (decoder.readIndex()); + if (unionIndex144 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(144, null); + } else { + if (unionIndex144 == 1) { + Utf8 charSequence144; + Object oldString144 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(144); + if (oldString144 instanceof Utf8) { + charSequence144 = (decoder).readString(((Utf8) oldString144)); + } else { + charSequence144 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(144, charSequence144); + } else { + throw new RuntimeException(("Illegal union index for 'F144': "+ unionIndex144)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex145 = (decoder.readIndex()); + if (unionIndex145 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(145, null); + } else { + if (unionIndex145 == 1) { + Utf8 charSequence145; + Object oldString145 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(145); + if (oldString145 instanceof Utf8) { + charSequence145 = (decoder).readString(((Utf8) oldString145)); + } else { + charSequence145 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(145, charSequence145); + } else { + throw new RuntimeException(("Illegal union index for 'F145': "+ unionIndex145)); + } + } + int unionIndex146 = (decoder.readIndex()); + if (unionIndex146 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(146, null); + } else { + if (unionIndex146 == 1) { + Utf8 charSequence146; + Object oldString146 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(146); + if (oldString146 instanceof Utf8) { + charSequence146 = (decoder).readString(((Utf8) oldString146)); + } else { + charSequence146 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(146, charSequence146); + } else { + throw new RuntimeException(("Illegal union index for 'F146': "+ unionIndex146)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex147 = (decoder.readIndex()); + if (unionIndex147 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(147, null); + } else { + if (unionIndex147 == 1) { + Utf8 charSequence147; + Object oldString147 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(147); + if (oldString147 instanceof Utf8) { + charSequence147 = (decoder).readString(((Utf8) oldString147)); + } else { + charSequence147 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(147, charSequence147); + } else { + throw new RuntimeException(("Illegal union index for 'F147': "+ unionIndex147)); + } + } + int unionIndex148 = (decoder.readIndex()); + if (unionIndex148 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(148, null); + } else { + if (unionIndex148 == 1) { + Utf8 charSequence148; + Object oldString148 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(148); + if (oldString148 instanceof Utf8) { + charSequence148 = (decoder).readString(((Utf8) oldString148)); + } else { + charSequence148 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(148, charSequence148); + } else { + throw new RuntimeException(("Illegal union index for 'F148': "+ unionIndex148)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex149 = (decoder.readIndex()); + if (unionIndex149 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(149, null); + } else { + if (unionIndex149 == 1) { + Utf8 charSequence149; + Object oldString149 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(149); + if (oldString149 instanceof Utf8) { + charSequence149 = (decoder).readString(((Utf8) oldString149)); + } else { + charSequence149 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(149, charSequence149); + } else { + throw new RuntimeException(("Illegal union index for 'F149': "+ unionIndex149)); + } + } + int unionIndex150 = (decoder.readIndex()); + if (unionIndex150 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(150, null); + } else { + if (unionIndex150 == 1) { + Utf8 charSequence150; + Object oldString150 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(150); + if (oldString150 instanceof Utf8) { + charSequence150 = (decoder).readString(((Utf8) oldString150)); + } else { + charSequence150 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(150, charSequence150); + } else { + throw new RuntimeException(("Illegal union index for 'F150': "+ unionIndex150)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex151 = (decoder.readIndex()); + if (unionIndex151 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(151, null); + } else { + if (unionIndex151 == 1) { + Utf8 charSequence151; + Object oldString151 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(151); + if (oldString151 instanceof Utf8) { + charSequence151 = (decoder).readString(((Utf8) oldString151)); + } else { + charSequence151 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(151, charSequence151); + } else { + throw new RuntimeException(("Illegal union index for 'F151': "+ unionIndex151)); + } + } + int unionIndex152 = (decoder.readIndex()); + if (unionIndex152 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(152, null); + } else { + if (unionIndex152 == 1) { + Utf8 charSequence152; + Object oldString152 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(152); + if (oldString152 instanceof Utf8) { + charSequence152 = (decoder).readString(((Utf8) oldString152)); + } else { + charSequence152 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(152, charSequence152); + } else { + throw new RuntimeException(("Illegal union index for 'F152': "+ unionIndex152)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex153 = (decoder.readIndex()); + if (unionIndex153 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(153, null); + } else { + if (unionIndex153 == 1) { + Utf8 charSequence153; + Object oldString153 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(153); + if (oldString153 instanceof Utf8) { + charSequence153 = (decoder).readString(((Utf8) oldString153)); + } else { + charSequence153 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(153, charSequence153); + } else { + throw new RuntimeException(("Illegal union index for 'F153': "+ unionIndex153)); + } + } + int unionIndex154 = (decoder.readIndex()); + if (unionIndex154 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(154, null); + } else { + if (unionIndex154 == 1) { + Utf8 charSequence154; + Object oldString154 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(154); + if (oldString154 instanceof Utf8) { + charSequence154 = (decoder).readString(((Utf8) oldString154)); + } else { + charSequence154 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(154, charSequence154); + } else { + throw new RuntimeException(("Illegal union index for 'F154': "+ unionIndex154)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex155 = (decoder.readIndex()); + if (unionIndex155 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(155, null); + } else { + if (unionIndex155 == 1) { + Utf8 charSequence155; + Object oldString155 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(155); + if (oldString155 instanceof Utf8) { + charSequence155 = (decoder).readString(((Utf8) oldString155)); + } else { + charSequence155 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(155, charSequence155); + } else { + throw new RuntimeException(("Illegal union index for 'F155': "+ unionIndex155)); + } + } + int unionIndex156 = (decoder.readIndex()); + if (unionIndex156 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(156, null); + } else { + if (unionIndex156 == 1) { + Utf8 charSequence156; + Object oldString156 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(156); + if (oldString156 instanceof Utf8) { + charSequence156 = (decoder).readString(((Utf8) oldString156)); + } else { + charSequence156 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(156, charSequence156); + } else { + throw new RuntimeException(("Illegal union index for 'F156': "+ unionIndex156)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex157 = (decoder.readIndex()); + if (unionIndex157 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(157, null); + } else { + if (unionIndex157 == 1) { + Utf8 charSequence157; + Object oldString157 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(157); + if (oldString157 instanceof Utf8) { + charSequence157 = (decoder).readString(((Utf8) oldString157)); + } else { + charSequence157 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(157, charSequence157); + } else { + throw new RuntimeException(("Illegal union index for 'F157': "+ unionIndex157)); + } + } + int unionIndex158 = (decoder.readIndex()); + if (unionIndex158 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(158, null); + } else { + if (unionIndex158 == 1) { + Utf8 charSequence158; + Object oldString158 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(158); + if (oldString158 instanceof Utf8) { + charSequence158 = (decoder).readString(((Utf8) oldString158)); + } else { + charSequence158 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(158, charSequence158); + } else { + throw new RuntimeException(("Illegal union index for 'F158': "+ unionIndex158)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex159 = (decoder.readIndex()); + if (unionIndex159 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(159, null); + } else { + if (unionIndex159 == 1) { + Utf8 charSequence159; + Object oldString159 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(159); + if (oldString159 instanceof Utf8) { + charSequence159 = (decoder).readString(((Utf8) oldString159)); + } else { + charSequence159 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(159, charSequence159); + } else { + throw new RuntimeException(("Illegal union index for 'F159': "+ unionIndex159)); + } + } + int unionIndex160 = (decoder.readIndex()); + if (unionIndex160 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(160, null); + } else { + if (unionIndex160 == 1) { + Utf8 charSequence160; + Object oldString160 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(160); + if (oldString160 instanceof Utf8) { + charSequence160 = (decoder).readString(((Utf8) oldString160)); + } else { + charSequence160 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(160, charSequence160); + } else { + throw new RuntimeException(("Illegal union index for 'F160': "+ unionIndex160)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex161 = (decoder.readIndex()); + if (unionIndex161 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(161, null); + } else { + if (unionIndex161 == 1) { + Utf8 charSequence161; + Object oldString161 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(161); + if (oldString161 instanceof Utf8) { + charSequence161 = (decoder).readString(((Utf8) oldString161)); + } else { + charSequence161 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(161, charSequence161); + } else { + throw new RuntimeException(("Illegal union index for 'F161': "+ unionIndex161)); + } + } + int unionIndex162 = (decoder.readIndex()); + if (unionIndex162 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(162, null); + } else { + if (unionIndex162 == 1) { + Utf8 charSequence162; + Object oldString162 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(162); + if (oldString162 instanceof Utf8) { + charSequence162 = (decoder).readString(((Utf8) oldString162)); + } else { + charSequence162 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(162, charSequence162); + } else { + throw new RuntimeException(("Illegal union index for 'F162': "+ unionIndex162)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex163 = (decoder.readIndex()); + if (unionIndex163 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(163, null); + } else { + if (unionIndex163 == 1) { + Utf8 charSequence163; + Object oldString163 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(163); + if (oldString163 instanceof Utf8) { + charSequence163 = (decoder).readString(((Utf8) oldString163)); + } else { + charSequence163 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(163, charSequence163); + } else { + throw new RuntimeException(("Illegal union index for 'F163': "+ unionIndex163)); + } + } + int unionIndex164 = (decoder.readIndex()); + if (unionIndex164 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(164, null); + } else { + if (unionIndex164 == 1) { + Utf8 charSequence164; + Object oldString164 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(164); + if (oldString164 instanceof Utf8) { + charSequence164 = (decoder).readString(((Utf8) oldString164)); + } else { + charSequence164 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(164, charSequence164); + } else { + throw new RuntimeException(("Illegal union index for 'F164': "+ unionIndex164)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex165 = (decoder.readIndex()); + if (unionIndex165 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(165, null); + } else { + if (unionIndex165 == 1) { + Utf8 charSequence165; + Object oldString165 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(165); + if (oldString165 instanceof Utf8) { + charSequence165 = (decoder).readString(((Utf8) oldString165)); + } else { + charSequence165 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(165, charSequence165); + } else { + throw new RuntimeException(("Illegal union index for 'F165': "+ unionIndex165)); + } + } + int unionIndex166 = (decoder.readIndex()); + if (unionIndex166 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(166, null); + } else { + if (unionIndex166 == 1) { + Utf8 charSequence166; + Object oldString166 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(166); + if (oldString166 instanceof Utf8) { + charSequence166 = (decoder).readString(((Utf8) oldString166)); + } else { + charSequence166 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(166, charSequence166); + } else { + throw new RuntimeException(("Illegal union index for 'F166': "+ unionIndex166)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex167 = (decoder.readIndex()); + if (unionIndex167 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(167, null); + } else { + if (unionIndex167 == 1) { + Utf8 charSequence167; + Object oldString167 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(167); + if (oldString167 instanceof Utf8) { + charSequence167 = (decoder).readString(((Utf8) oldString167)); + } else { + charSequence167 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(167, charSequence167); + } else { + throw new RuntimeException(("Illegal union index for 'F167': "+ unionIndex167)); + } + } + int unionIndex168 = (decoder.readIndex()); + if (unionIndex168 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(168, null); + } else { + if (unionIndex168 == 1) { + Utf8 charSequence168; + Object oldString168 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(168); + if (oldString168 instanceof Utf8) { + charSequence168 = (decoder).readString(((Utf8) oldString168)); + } else { + charSequence168 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(168, charSequence168); + } else { + throw new RuntimeException(("Illegal union index for 'F168': "+ unionIndex168)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex169 = (decoder.readIndex()); + if (unionIndex169 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(169, null); + } else { + if (unionIndex169 == 1) { + Utf8 charSequence169; + Object oldString169 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(169); + if (oldString169 instanceof Utf8) { + charSequence169 = (decoder).readString(((Utf8) oldString169)); + } else { + charSequence169 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(169, charSequence169); + } else { + throw new RuntimeException(("Illegal union index for 'F169': "+ unionIndex169)); + } + } + int unionIndex170 = (decoder.readIndex()); + if (unionIndex170 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(170, null); + } else { + if (unionIndex170 == 1) { + Utf8 charSequence170; + Object oldString170 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(170); + if (oldString170 instanceof Utf8) { + charSequence170 = (decoder).readString(((Utf8) oldString170)); + } else { + charSequence170 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(170, charSequence170); + } else { + throw new RuntimeException(("Illegal union index for 'F170': "+ unionIndex170)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex171 = (decoder.readIndex()); + if (unionIndex171 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(171, null); + } else { + if (unionIndex171 == 1) { + Utf8 charSequence171; + Object oldString171 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(171); + if (oldString171 instanceof Utf8) { + charSequence171 = (decoder).readString(((Utf8) oldString171)); + } else { + charSequence171 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(171, charSequence171); + } else { + throw new RuntimeException(("Illegal union index for 'F171': "+ unionIndex171)); + } + } + int unionIndex172 = (decoder.readIndex()); + if (unionIndex172 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(172, null); + } else { + if (unionIndex172 == 1) { + Utf8 charSequence172; + Object oldString172 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(172); + if (oldString172 instanceof Utf8) { + charSequence172 = (decoder).readString(((Utf8) oldString172)); + } else { + charSequence172 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(172, charSequence172); + } else { + throw new RuntimeException(("Illegal union index for 'F172': "+ unionIndex172)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex173 = (decoder.readIndex()); + if (unionIndex173 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(173, null); + } else { + if (unionIndex173 == 1) { + Utf8 charSequence173; + Object oldString173 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(173); + if (oldString173 instanceof Utf8) { + charSequence173 = (decoder).readString(((Utf8) oldString173)); + } else { + charSequence173 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(173, charSequence173); + } else { + throw new RuntimeException(("Illegal union index for 'F173': "+ unionIndex173)); + } + } + int unionIndex174 = (decoder.readIndex()); + if (unionIndex174 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(174, null); + } else { + if (unionIndex174 == 1) { + Utf8 charSequence174; + Object oldString174 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(174); + if (oldString174 instanceof Utf8) { + charSequence174 = (decoder).readString(((Utf8) oldString174)); + } else { + charSequence174 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(174, charSequence174); + } else { + throw new RuntimeException(("Illegal union index for 'F174': "+ unionIndex174)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex175 = (decoder.readIndex()); + if (unionIndex175 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(175, null); + } else { + if (unionIndex175 == 1) { + Utf8 charSequence175; + Object oldString175 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(175); + if (oldString175 instanceof Utf8) { + charSequence175 = (decoder).readString(((Utf8) oldString175)); + } else { + charSequence175 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(175, charSequence175); + } else { + throw new RuntimeException(("Illegal union index for 'F175': "+ unionIndex175)); + } + } + int unionIndex176 = (decoder.readIndex()); + if (unionIndex176 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(176, null); + } else { + if (unionIndex176 == 1) { + Utf8 charSequence176; + Object oldString176 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(176); + if (oldString176 instanceof Utf8) { + charSequence176 = (decoder).readString(((Utf8) oldString176)); + } else { + charSequence176 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(176, charSequence176); + } else { + throw new RuntimeException(("Illegal union index for 'F176': "+ unionIndex176)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex177 = (decoder.readIndex()); + if (unionIndex177 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(177, null); + } else { + if (unionIndex177 == 1) { + Utf8 charSequence177; + Object oldString177 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(177); + if (oldString177 instanceof Utf8) { + charSequence177 = (decoder).readString(((Utf8) oldString177)); + } else { + charSequence177 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(177, charSequence177); + } else { + throw new RuntimeException(("Illegal union index for 'F177': "+ unionIndex177)); + } + } + int unionIndex178 = (decoder.readIndex()); + if (unionIndex178 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(178, null); + } else { + if (unionIndex178 == 1) { + Utf8 charSequence178; + Object oldString178 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(178); + if (oldString178 instanceof Utf8) { + charSequence178 = (decoder).readString(((Utf8) oldString178)); + } else { + charSequence178 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(178, charSequence178); + } else { + throw new RuntimeException(("Illegal union index for 'F178': "+ unionIndex178)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex179 = (decoder.readIndex()); + if (unionIndex179 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(179, null); + } else { + if (unionIndex179 == 1) { + Utf8 charSequence179; + Object oldString179 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(179); + if (oldString179 instanceof Utf8) { + charSequence179 = (decoder).readString(((Utf8) oldString179)); + } else { + charSequence179 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(179, charSequence179); + } else { + throw new RuntimeException(("Illegal union index for 'F179': "+ unionIndex179)); + } + } + int unionIndex180 = (decoder.readIndex()); + if (unionIndex180 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(180, null); + } else { + if (unionIndex180 == 1) { + Utf8 charSequence180; + Object oldString180 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(180); + if (oldString180 instanceof Utf8) { + charSequence180 = (decoder).readString(((Utf8) oldString180)); + } else { + charSequence180 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(180, charSequence180); + } else { + throw new RuntimeException(("Illegal union index for 'F180': "+ unionIndex180)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex181 = (decoder.readIndex()); + if (unionIndex181 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(181, null); + } else { + if (unionIndex181 == 1) { + Utf8 charSequence181; + Object oldString181 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(181); + if (oldString181 instanceof Utf8) { + charSequence181 = (decoder).readString(((Utf8) oldString181)); + } else { + charSequence181 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(181, charSequence181); + } else { + throw new RuntimeException(("Illegal union index for 'F181': "+ unionIndex181)); + } + } + int unionIndex182 = (decoder.readIndex()); + if (unionIndex182 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(182, null); + } else { + if (unionIndex182 == 1) { + Utf8 charSequence182; + Object oldString182 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(182); + if (oldString182 instanceof Utf8) { + charSequence182 = (decoder).readString(((Utf8) oldString182)); + } else { + charSequence182 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(182, charSequence182); + } else { + throw new RuntimeException(("Illegal union index for 'F182': "+ unionIndex182)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex183 = (decoder.readIndex()); + if (unionIndex183 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(183, null); + } else { + if (unionIndex183 == 1) { + Utf8 charSequence183; + Object oldString183 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(183); + if (oldString183 instanceof Utf8) { + charSequence183 = (decoder).readString(((Utf8) oldString183)); + } else { + charSequence183 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(183, charSequence183); + } else { + throw new RuntimeException(("Illegal union index for 'F183': "+ unionIndex183)); + } + } + int unionIndex184 = (decoder.readIndex()); + if (unionIndex184 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(184, null); + } else { + if (unionIndex184 == 1) { + Utf8 charSequence184; + Object oldString184 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(184); + if (oldString184 instanceof Utf8) { + charSequence184 = (decoder).readString(((Utf8) oldString184)); + } else { + charSequence184 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(184, charSequence184); + } else { + throw new RuntimeException(("Illegal union index for 'F184': "+ unionIndex184)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex185 = (decoder.readIndex()); + if (unionIndex185 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(185, null); + } else { + if (unionIndex185 == 1) { + Utf8 charSequence185; + Object oldString185 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(185); + if (oldString185 instanceof Utf8) { + charSequence185 = (decoder).readString(((Utf8) oldString185)); + } else { + charSequence185 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(185, charSequence185); + } else { + throw new RuntimeException(("Illegal union index for 'F185': "+ unionIndex185)); + } + } + int unionIndex186 = (decoder.readIndex()); + if (unionIndex186 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(186, null); + } else { + if (unionIndex186 == 1) { + Utf8 charSequence186; + Object oldString186 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(186); + if (oldString186 instanceof Utf8) { + charSequence186 = (decoder).readString(((Utf8) oldString186)); + } else { + charSequence186 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(186, charSequence186); + } else { + throw new RuntimeException(("Illegal union index for 'F186': "+ unionIndex186)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex187 = (decoder.readIndex()); + if (unionIndex187 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(187, null); + } else { + if (unionIndex187 == 1) { + Utf8 charSequence187; + Object oldString187 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(187); + if (oldString187 instanceof Utf8) { + charSequence187 = (decoder).readString(((Utf8) oldString187)); + } else { + charSequence187 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(187, charSequence187); + } else { + throw new RuntimeException(("Illegal union index for 'F187': "+ unionIndex187)); + } + } + int unionIndex188 = (decoder.readIndex()); + if (unionIndex188 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(188, null); + } else { + if (unionIndex188 == 1) { + Utf8 charSequence188; + Object oldString188 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(188); + if (oldString188 instanceof Utf8) { + charSequence188 = (decoder).readString(((Utf8) oldString188)); + } else { + charSequence188 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(188, charSequence188); + } else { + throw new RuntimeException(("Illegal union index for 'F188': "+ unionIndex188)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex189 = (decoder.readIndex()); + if (unionIndex189 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(189, null); + } else { + if (unionIndex189 == 1) { + Utf8 charSequence189; + Object oldString189 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(189); + if (oldString189 instanceof Utf8) { + charSequence189 = (decoder).readString(((Utf8) oldString189)); + } else { + charSequence189 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(189, charSequence189); + } else { + throw new RuntimeException(("Illegal union index for 'F189': "+ unionIndex189)); + } + } + int unionIndex190 = (decoder.readIndex()); + if (unionIndex190 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(190, null); + } else { + if (unionIndex190 == 1) { + Utf8 charSequence190; + Object oldString190 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(190); + if (oldString190 instanceof Utf8) { + charSequence190 = (decoder).readString(((Utf8) oldString190)); + } else { + charSequence190 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(190, charSequence190); + } else { + throw new RuntimeException(("Illegal union index for 'F190': "+ unionIndex190)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex191 = (decoder.readIndex()); + if (unionIndex191 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(191, null); + } else { + if (unionIndex191 == 1) { + Utf8 charSequence191; + Object oldString191 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(191); + if (oldString191 instanceof Utf8) { + charSequence191 = (decoder).readString(((Utf8) oldString191)); + } else { + charSequence191 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(191, charSequence191); + } else { + throw new RuntimeException(("Illegal union index for 'F191': "+ unionIndex191)); + } + } + int unionIndex192 = (decoder.readIndex()); + if (unionIndex192 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(192, null); + } else { + if (unionIndex192 == 1) { + Utf8 charSequence192; + Object oldString192 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(192); + if (oldString192 instanceof Utf8) { + charSequence192 = (decoder).readString(((Utf8) oldString192)); + } else { + charSequence192 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(192, charSequence192); + } else { + throw new RuntimeException(("Illegal union index for 'F192': "+ unionIndex192)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex193 = (decoder.readIndex()); + if (unionIndex193 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(193, null); + } else { + if (unionIndex193 == 1) { + Utf8 charSequence193; + Object oldString193 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(193); + if (oldString193 instanceof Utf8) { + charSequence193 = (decoder).readString(((Utf8) oldString193)); + } else { + charSequence193 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(193, charSequence193); + } else { + throw new RuntimeException(("Illegal union index for 'F193': "+ unionIndex193)); + } + } + int unionIndex194 = (decoder.readIndex()); + if (unionIndex194 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(194, null); + } else { + if (unionIndex194 == 1) { + Utf8 charSequence194; + Object oldString194 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(194); + if (oldString194 instanceof Utf8) { + charSequence194 = (decoder).readString(((Utf8) oldString194)); + } else { + charSequence194 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(194, charSequence194); + } else { + throw new RuntimeException(("Illegal union index for 'F194': "+ unionIndex194)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex195 = (decoder.readIndex()); + if (unionIndex195 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(195, null); + } else { + if (unionIndex195 == 1) { + Utf8 charSequence195; + Object oldString195 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(195); + if (oldString195 instanceof Utf8) { + charSequence195 = (decoder).readString(((Utf8) oldString195)); + } else { + charSequence195 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(195, charSequence195); + } else { + throw new RuntimeException(("Illegal union index for 'F195': "+ unionIndex195)); + } + } + int unionIndex196 = (decoder.readIndex()); + if (unionIndex196 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(196, null); + } else { + if (unionIndex196 == 1) { + Utf8 charSequence196; + Object oldString196 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(196); + if (oldString196 instanceof Utf8) { + charSequence196 = (decoder).readString(((Utf8) oldString196)); + } else { + charSequence196 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(196, charSequence196); + } else { + throw new RuntimeException(("Illegal union index for 'F196': "+ unionIndex196)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex197 = (decoder.readIndex()); + if (unionIndex197 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(197, null); + } else { + if (unionIndex197 == 1) { + Utf8 charSequence197; + Object oldString197 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(197); + if (oldString197 instanceof Utf8) { + charSequence197 = (decoder).readString(((Utf8) oldString197)); + } else { + charSequence197 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(197, charSequence197); + } else { + throw new RuntimeException(("Illegal union index for 'F197': "+ unionIndex197)); + } + } + int unionIndex198 = (decoder.readIndex()); + if (unionIndex198 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(198, null); + } else { + if (unionIndex198 == 1) { + Utf8 charSequence198; + Object oldString198 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(198); + if (oldString198 instanceof Utf8) { + charSequence198 = (decoder).readString(((Utf8) oldString198)); + } else { + charSequence198 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(198, charSequence198); + } else { + throw new RuntimeException(("Illegal union index for 'F198': "+ unionIndex198)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex199 = (decoder.readIndex()); + if (unionIndex199 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(199, null); + } else { + if (unionIndex199 == 1) { + Utf8 charSequence199; + Object oldString199 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(199); + if (oldString199 instanceof Utf8) { + charSequence199 = (decoder).readString(((Utf8) oldString199)); + } else { + charSequence199 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(199, charSequence199); + } else { + throw new RuntimeException(("Illegal union index for 'F199': "+ unionIndex199)); + } + } + int unionIndex200 = (decoder.readIndex()); + if (unionIndex200 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(200, null); + } else { + if (unionIndex200 == 1) { + Utf8 charSequence200; + Object oldString200 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(200); + if (oldString200 instanceof Utf8) { + charSequence200 = (decoder).readString(((Utf8) oldString200)); + } else { + charSequence200 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(200, charSequence200); + } else { + throw new RuntimeException(("Illegal union index for 'F200': "+ unionIndex200)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex201 = (decoder.readIndex()); + if (unionIndex201 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(201, null); + } else { + if (unionIndex201 == 1) { + Utf8 charSequence201; + Object oldString201 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(201); + if (oldString201 instanceof Utf8) { + charSequence201 = (decoder).readString(((Utf8) oldString201)); + } else { + charSequence201 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(201, charSequence201); + } else { + throw new RuntimeException(("Illegal union index for 'F201': "+ unionIndex201)); + } + } + int unionIndex202 = (decoder.readIndex()); + if (unionIndex202 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(202, null); + } else { + if (unionIndex202 == 1) { + Utf8 charSequence202; + Object oldString202 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(202); + if (oldString202 instanceof Utf8) { + charSequence202 = (decoder).readString(((Utf8) oldString202)); + } else { + charSequence202 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(202, charSequence202); + } else { + throw new RuntimeException(("Illegal union index for 'F202': "+ unionIndex202)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex203 = (decoder.readIndex()); + if (unionIndex203 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(203, null); + } else { + if (unionIndex203 == 1) { + Utf8 charSequence203; + Object oldString203 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(203); + if (oldString203 instanceof Utf8) { + charSequence203 = (decoder).readString(((Utf8) oldString203)); + } else { + charSequence203 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(203, charSequence203); + } else { + throw new RuntimeException(("Illegal union index for 'F203': "+ unionIndex203)); + } + } + int unionIndex204 = (decoder.readIndex()); + if (unionIndex204 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(204, null); + } else { + if (unionIndex204 == 1) { + Utf8 charSequence204; + Object oldString204 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(204); + if (oldString204 instanceof Utf8) { + charSequence204 = (decoder).readString(((Utf8) oldString204)); + } else { + charSequence204 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(204, charSequence204); + } else { + throw new RuntimeException(("Illegal union index for 'F204': "+ unionIndex204)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex205 = (decoder.readIndex()); + if (unionIndex205 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(205, null); + } else { + if (unionIndex205 == 1) { + Utf8 charSequence205; + Object oldString205 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(205); + if (oldString205 instanceof Utf8) { + charSequence205 = (decoder).readString(((Utf8) oldString205)); + } else { + charSequence205 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(205, charSequence205); + } else { + throw new RuntimeException(("Illegal union index for 'F205': "+ unionIndex205)); + } + } + int unionIndex206 = (decoder.readIndex()); + if (unionIndex206 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(206, null); + } else { + if (unionIndex206 == 1) { + Utf8 charSequence206; + Object oldString206 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(206); + if (oldString206 instanceof Utf8) { + charSequence206 = (decoder).readString(((Utf8) oldString206)); + } else { + charSequence206 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(206, charSequence206); + } else { + throw new RuntimeException(("Illegal union index for 'F206': "+ unionIndex206)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex207 = (decoder.readIndex()); + if (unionIndex207 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(207, null); + } else { + if (unionIndex207 == 1) { + Utf8 charSequence207; + Object oldString207 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(207); + if (oldString207 instanceof Utf8) { + charSequence207 = (decoder).readString(((Utf8) oldString207)); + } else { + charSequence207 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(207, charSequence207); + } else { + throw new RuntimeException(("Illegal union index for 'F207': "+ unionIndex207)); + } + } + int unionIndex208 = (decoder.readIndex()); + if (unionIndex208 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(208, null); + } else { + if (unionIndex208 == 1) { + Utf8 charSequence208; + Object oldString208 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(208); + if (oldString208 instanceof Utf8) { + charSequence208 = (decoder).readString(((Utf8) oldString208)); + } else { + charSequence208 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(208, charSequence208); + } else { + throw new RuntimeException(("Illegal union index for 'F208': "+ unionIndex208)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex209 = (decoder.readIndex()); + if (unionIndex209 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(209, null); + } else { + if (unionIndex209 == 1) { + Utf8 charSequence209; + Object oldString209 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(209); + if (oldString209 instanceof Utf8) { + charSequence209 = (decoder).readString(((Utf8) oldString209)); + } else { + charSequence209 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(209, charSequence209); + } else { + throw new RuntimeException(("Illegal union index for 'F209': "+ unionIndex209)); + } + } + int unionIndex210 = (decoder.readIndex()); + if (unionIndex210 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(210, null); + } else { + if (unionIndex210 == 1) { + Utf8 charSequence210; + Object oldString210 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(210); + if (oldString210 instanceof Utf8) { + charSequence210 = (decoder).readString(((Utf8) oldString210)); + } else { + charSequence210 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(210, charSequence210); + } else { + throw new RuntimeException(("Illegal union index for 'F210': "+ unionIndex210)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex211 = (decoder.readIndex()); + if (unionIndex211 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(211, null); + } else { + if (unionIndex211 == 1) { + Utf8 charSequence211; + Object oldString211 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(211); + if (oldString211 instanceof Utf8) { + charSequence211 = (decoder).readString(((Utf8) oldString211)); + } else { + charSequence211 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(211, charSequence211); + } else { + throw new RuntimeException(("Illegal union index for 'F211': "+ unionIndex211)); + } + } + int unionIndex212 = (decoder.readIndex()); + if (unionIndex212 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(212, null); + } else { + if (unionIndex212 == 1) { + Utf8 charSequence212; + Object oldString212 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(212); + if (oldString212 instanceof Utf8) { + charSequence212 = (decoder).readString(((Utf8) oldString212)); + } else { + charSequence212 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(212, charSequence212); + } else { + throw new RuntimeException(("Illegal union index for 'F212': "+ unionIndex212)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex213 = (decoder.readIndex()); + if (unionIndex213 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(213, null); + } else { + if (unionIndex213 == 1) { + Utf8 charSequence213; + Object oldString213 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(213); + if (oldString213 instanceof Utf8) { + charSequence213 = (decoder).readString(((Utf8) oldString213)); + } else { + charSequence213 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(213, charSequence213); + } else { + throw new RuntimeException(("Illegal union index for 'F213': "+ unionIndex213)); + } + } + int unionIndex214 = (decoder.readIndex()); + if (unionIndex214 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(214, null); + } else { + if (unionIndex214 == 1) { + Utf8 charSequence214; + Object oldString214 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(214); + if (oldString214 instanceof Utf8) { + charSequence214 = (decoder).readString(((Utf8) oldString214)); + } else { + charSequence214 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(214, charSequence214); + } else { + throw new RuntimeException(("Illegal union index for 'F214': "+ unionIndex214)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex215 = (decoder.readIndex()); + if (unionIndex215 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(215, null); + } else { + if (unionIndex215 == 1) { + Utf8 charSequence215; + Object oldString215 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(215); + if (oldString215 instanceof Utf8) { + charSequence215 = (decoder).readString(((Utf8) oldString215)); + } else { + charSequence215 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(215, charSequence215); + } else { + throw new RuntimeException(("Illegal union index for 'F215': "+ unionIndex215)); + } + } + int unionIndex216 = (decoder.readIndex()); + if (unionIndex216 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(216, null); + } else { + if (unionIndex216 == 1) { + Utf8 charSequence216; + Object oldString216 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(216); + if (oldString216 instanceof Utf8) { + charSequence216 = (decoder).readString(((Utf8) oldString216)); + } else { + charSequence216 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(216, charSequence216); + } else { + throw new RuntimeException(("Illegal union index for 'F216': "+ unionIndex216)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex217 = (decoder.readIndex()); + if (unionIndex217 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(217, null); + } else { + if (unionIndex217 == 1) { + Utf8 charSequence217; + Object oldString217 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(217); + if (oldString217 instanceof Utf8) { + charSequence217 = (decoder).readString(((Utf8) oldString217)); + } else { + charSequence217 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(217, charSequence217); + } else { + throw new RuntimeException(("Illegal union index for 'F217': "+ unionIndex217)); + } + } + int unionIndex218 = (decoder.readIndex()); + if (unionIndex218 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(218, null); + } else { + if (unionIndex218 == 1) { + Utf8 charSequence218; + Object oldString218 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(218); + if (oldString218 instanceof Utf8) { + charSequence218 = (decoder).readString(((Utf8) oldString218)); + } else { + charSequence218 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(218, charSequence218); + } else { + throw new RuntimeException(("Illegal union index for 'F218': "+ unionIndex218)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex219 = (decoder.readIndex()); + if (unionIndex219 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(219, null); + } else { + if (unionIndex219 == 1) { + Utf8 charSequence219; + Object oldString219 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(219); + if (oldString219 instanceof Utf8) { + charSequence219 = (decoder).readString(((Utf8) oldString219)); + } else { + charSequence219 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(219, charSequence219); + } else { + throw new RuntimeException(("Illegal union index for 'F219': "+ unionIndex219)); + } + } + int unionIndex220 = (decoder.readIndex()); + if (unionIndex220 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(220, null); + } else { + if (unionIndex220 == 1) { + Utf8 charSequence220; + Object oldString220 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(220); + if (oldString220 instanceof Utf8) { + charSequence220 = (decoder).readString(((Utf8) oldString220)); + } else { + charSequence220 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(220, charSequence220); + } else { + throw new RuntimeException(("Illegal union index for 'F220': "+ unionIndex220)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex221 = (decoder.readIndex()); + if (unionIndex221 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(221, null); + } else { + if (unionIndex221 == 1) { + Utf8 charSequence221; + Object oldString221 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(221); + if (oldString221 instanceof Utf8) { + charSequence221 = (decoder).readString(((Utf8) oldString221)); + } else { + charSequence221 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(221, charSequence221); + } else { + throw new RuntimeException(("Illegal union index for 'F221': "+ unionIndex221)); + } + } + int unionIndex222 = (decoder.readIndex()); + if (unionIndex222 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(222, null); + } else { + if (unionIndex222 == 1) { + Utf8 charSequence222; + Object oldString222 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(222); + if (oldString222 instanceof Utf8) { + charSequence222 = (decoder).readString(((Utf8) oldString222)); + } else { + charSequence222 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(222, charSequence222); + } else { + throw new RuntimeException(("Illegal union index for 'F222': "+ unionIndex222)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex223 = (decoder.readIndex()); + if (unionIndex223 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(223, null); + } else { + if (unionIndex223 == 1) { + Utf8 charSequence223; + Object oldString223 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(223); + if (oldString223 instanceof Utf8) { + charSequence223 = (decoder).readString(((Utf8) oldString223)); + } else { + charSequence223 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(223, charSequence223); + } else { + throw new RuntimeException(("Illegal union index for 'F223': "+ unionIndex223)); + } + } + int unionIndex224 = (decoder.readIndex()); + if (unionIndex224 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(224, null); + } else { + if (unionIndex224 == 1) { + Utf8 charSequence224; + Object oldString224 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(224); + if (oldString224 instanceof Utf8) { + charSequence224 = (decoder).readString(((Utf8) oldString224)); + } else { + charSequence224 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(224, charSequence224); + } else { + throw new RuntimeException(("Illegal union index for 'F224': "+ unionIndex224)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex225 = (decoder.readIndex()); + if (unionIndex225 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(225, null); + } else { + if (unionIndex225 == 1) { + Utf8 charSequence225; + Object oldString225 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(225); + if (oldString225 instanceof Utf8) { + charSequence225 = (decoder).readString(((Utf8) oldString225)); + } else { + charSequence225 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(225, charSequence225); + } else { + throw new RuntimeException(("Illegal union index for 'F225': "+ unionIndex225)); + } + } + int unionIndex226 = (decoder.readIndex()); + if (unionIndex226 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(226, null); + } else { + if (unionIndex226 == 1) { + Utf8 charSequence226; + Object oldString226 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(226); + if (oldString226 instanceof Utf8) { + charSequence226 = (decoder).readString(((Utf8) oldString226)); + } else { + charSequence226 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(226, charSequence226); + } else { + throw new RuntimeException(("Illegal union index for 'F226': "+ unionIndex226)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex227 = (decoder.readIndex()); + if (unionIndex227 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(227, null); + } else { + if (unionIndex227 == 1) { + Utf8 charSequence227; + Object oldString227 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(227); + if (oldString227 instanceof Utf8) { + charSequence227 = (decoder).readString(((Utf8) oldString227)); + } else { + charSequence227 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(227, charSequence227); + } else { + throw new RuntimeException(("Illegal union index for 'F227': "+ unionIndex227)); + } + } + int unionIndex228 = (decoder.readIndex()); + if (unionIndex228 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(228, null); + } else { + if (unionIndex228 == 1) { + Utf8 charSequence228; + Object oldString228 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(228); + if (oldString228 instanceof Utf8) { + charSequence228 = (decoder).readString(((Utf8) oldString228)); + } else { + charSequence228 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(228, charSequence228); + } else { + throw new RuntimeException(("Illegal union index for 'F228': "+ unionIndex228)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex229 = (decoder.readIndex()); + if (unionIndex229 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(229, null); + } else { + if (unionIndex229 == 1) { + Utf8 charSequence229; + Object oldString229 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(229); + if (oldString229 instanceof Utf8) { + charSequence229 = (decoder).readString(((Utf8) oldString229)); + } else { + charSequence229 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(229, charSequence229); + } else { + throw new RuntimeException(("Illegal union index for 'F229': "+ unionIndex229)); + } + } + int unionIndex230 = (decoder.readIndex()); + if (unionIndex230 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(230, null); + } else { + if (unionIndex230 == 1) { + Utf8 charSequence230; + Object oldString230 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(230); + if (oldString230 instanceof Utf8) { + charSequence230 = (decoder).readString(((Utf8) oldString230)); + } else { + charSequence230 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(230, charSequence230); + } else { + throw new RuntimeException(("Illegal union index for 'F230': "+ unionIndex230)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex231 = (decoder.readIndex()); + if (unionIndex231 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(231, null); + } else { + if (unionIndex231 == 1) { + Utf8 charSequence231; + Object oldString231 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(231); + if (oldString231 instanceof Utf8) { + charSequence231 = (decoder).readString(((Utf8) oldString231)); + } else { + charSequence231 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(231, charSequence231); + } else { + throw new RuntimeException(("Illegal union index for 'F231': "+ unionIndex231)); + } + } + int unionIndex232 = (decoder.readIndex()); + if (unionIndex232 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(232, null); + } else { + if (unionIndex232 == 1) { + Utf8 charSequence232; + Object oldString232 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(232); + if (oldString232 instanceof Utf8) { + charSequence232 = (decoder).readString(((Utf8) oldString232)); + } else { + charSequence232 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(232, charSequence232); + } else { + throw new RuntimeException(("Illegal union index for 'F232': "+ unionIndex232)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex233 = (decoder.readIndex()); + if (unionIndex233 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(233, null); + } else { + if (unionIndex233 == 1) { + Utf8 charSequence233; + Object oldString233 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(233); + if (oldString233 instanceof Utf8) { + charSequence233 = (decoder).readString(((Utf8) oldString233)); + } else { + charSequence233 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(233, charSequence233); + } else { + throw new RuntimeException(("Illegal union index for 'F233': "+ unionIndex233)); + } + } + int unionIndex234 = (decoder.readIndex()); + if (unionIndex234 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(234, null); + } else { + if (unionIndex234 == 1) { + Utf8 charSequence234; + Object oldString234 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(234); + if (oldString234 instanceof Utf8) { + charSequence234 = (decoder).readString(((Utf8) oldString234)); + } else { + charSequence234 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(234, charSequence234); + } else { + throw new RuntimeException(("Illegal union index for 'F234': "+ unionIndex234)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex235 = (decoder.readIndex()); + if (unionIndex235 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(235, null); + } else { + if (unionIndex235 == 1) { + Utf8 charSequence235; + Object oldString235 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(235); + if (oldString235 instanceof Utf8) { + charSequence235 = (decoder).readString(((Utf8) oldString235)); + } else { + charSequence235 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(235, charSequence235); + } else { + throw new RuntimeException(("Illegal union index for 'F235': "+ unionIndex235)); + } + } + int unionIndex236 = (decoder.readIndex()); + if (unionIndex236 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(236, null); + } else { + if (unionIndex236 == 1) { + Utf8 charSequence236; + Object oldString236 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(236); + if (oldString236 instanceof Utf8) { + charSequence236 = (decoder).readString(((Utf8) oldString236)); + } else { + charSequence236 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(236, charSequence236); + } else { + throw new RuntimeException(("Illegal union index for 'F236': "+ unionIndex236)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex237 = (decoder.readIndex()); + if (unionIndex237 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(237, null); + } else { + if (unionIndex237 == 1) { + Utf8 charSequence237; + Object oldString237 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(237); + if (oldString237 instanceof Utf8) { + charSequence237 = (decoder).readString(((Utf8) oldString237)); + } else { + charSequence237 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(237, charSequence237); + } else { + throw new RuntimeException(("Illegal union index for 'F237': "+ unionIndex237)); + } + } + int unionIndex238 = (decoder.readIndex()); + if (unionIndex238 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(238, null); + } else { + if (unionIndex238 == 1) { + Utf8 charSequence238; + Object oldString238 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(238); + if (oldString238 instanceof Utf8) { + charSequence238 = (decoder).readString(((Utf8) oldString238)); + } else { + charSequence238 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(238, charSequence238); + } else { + throw new RuntimeException(("Illegal union index for 'F238': "+ unionIndex238)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex239 = (decoder.readIndex()); + if (unionIndex239 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(239, null); + } else { + if (unionIndex239 == 1) { + Utf8 charSequence239; + Object oldString239 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(239); + if (oldString239 instanceof Utf8) { + charSequence239 = (decoder).readString(((Utf8) oldString239)); + } else { + charSequence239 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(239, charSequence239); + } else { + throw new RuntimeException(("Illegal union index for 'F239': "+ unionIndex239)); + } + } + int unionIndex240 = (decoder.readIndex()); + if (unionIndex240 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(240, null); + } else { + if (unionIndex240 == 1) { + Utf8 charSequence240; + Object oldString240 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(240); + if (oldString240 instanceof Utf8) { + charSequence240 = (decoder).readString(((Utf8) oldString240)); + } else { + charSequence240 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(240, charSequence240); + } else { + throw new RuntimeException(("Illegal union index for 'F240': "+ unionIndex240)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex241 = (decoder.readIndex()); + if (unionIndex241 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(241, null); + } else { + if (unionIndex241 == 1) { + Utf8 charSequence241; + Object oldString241 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(241); + if (oldString241 instanceof Utf8) { + charSequence241 = (decoder).readString(((Utf8) oldString241)); + } else { + charSequence241 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(241, charSequence241); + } else { + throw new RuntimeException(("Illegal union index for 'F241': "+ unionIndex241)); + } + } + int unionIndex242 = (decoder.readIndex()); + if (unionIndex242 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(242, null); + } else { + if (unionIndex242 == 1) { + Utf8 charSequence242; + Object oldString242 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(242); + if (oldString242 instanceof Utf8) { + charSequence242 = (decoder).readString(((Utf8) oldString242)); + } else { + charSequence242 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(242, charSequence242); + } else { + throw new RuntimeException(("Illegal union index for 'F242': "+ unionIndex242)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex243 = (decoder.readIndex()); + if (unionIndex243 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(243, null); + } else { + if (unionIndex243 == 1) { + Utf8 charSequence243; + Object oldString243 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(243); + if (oldString243 instanceof Utf8) { + charSequence243 = (decoder).readString(((Utf8) oldString243)); + } else { + charSequence243 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(243, charSequence243); + } else { + throw new RuntimeException(("Illegal union index for 'F243': "+ unionIndex243)); + } + } + int unionIndex244 = (decoder.readIndex()); + if (unionIndex244 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(244, null); + } else { + if (unionIndex244 == 1) { + Utf8 charSequence244; + Object oldString244 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(244); + if (oldString244 instanceof Utf8) { + charSequence244 = (decoder).readString(((Utf8) oldString244)); + } else { + charSequence244 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(244, charSequence244); + } else { + throw new RuntimeException(("Illegal union index for 'F244': "+ unionIndex244)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex245 = (decoder.readIndex()); + if (unionIndex245 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(245, null); + } else { + if (unionIndex245 == 1) { + Utf8 charSequence245; + Object oldString245 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(245); + if (oldString245 instanceof Utf8) { + charSequence245 = (decoder).readString(((Utf8) oldString245)); + } else { + charSequence245 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(245, charSequence245); + } else { + throw new RuntimeException(("Illegal union index for 'F245': "+ unionIndex245)); + } + } + int unionIndex246 = (decoder.readIndex()); + if (unionIndex246 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(246, null); + } else { + if (unionIndex246 == 1) { + Utf8 charSequence246; + Object oldString246 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(246); + if (oldString246 instanceof Utf8) { + charSequence246 = (decoder).readString(((Utf8) oldString246)); + } else { + charSequence246 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(246, charSequence246); + } else { + throw new RuntimeException(("Illegal union index for 'F246': "+ unionIndex246)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex247 = (decoder.readIndex()); + if (unionIndex247 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(247, null); + } else { + if (unionIndex247 == 1) { + Utf8 charSequence247; + Object oldString247 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(247); + if (oldString247 instanceof Utf8) { + charSequence247 = (decoder).readString(((Utf8) oldString247)); + } else { + charSequence247 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(247, charSequence247); + } else { + throw new RuntimeException(("Illegal union index for 'F247': "+ unionIndex247)); + } + } + int unionIndex248 = (decoder.readIndex()); + if (unionIndex248 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(248, null); + } else { + if (unionIndex248 == 1) { + Utf8 charSequence248; + Object oldString248 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(248); + if (oldString248 instanceof Utf8) { + charSequence248 = (decoder).readString(((Utf8) oldString248)); + } else { + charSequence248 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(248, charSequence248); + } else { + throw new RuntimeException(("Illegal union index for 'F248': "+ unionIndex248)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex249 = (decoder.readIndex()); + if (unionIndex249 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(249, null); + } else { + if (unionIndex249 == 1) { + Utf8 charSequence249; + Object oldString249 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(249); + if (oldString249 instanceof Utf8) { + charSequence249 = (decoder).readString(((Utf8) oldString249)); + } else { + charSequence249 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(249, charSequence249); + } else { + throw new RuntimeException(("Illegal union index for 'F249': "+ unionIndex249)); + } + } + int unionIndex250 = (decoder.readIndex()); + if (unionIndex250 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(250, null); + } else { + if (unionIndex250 == 1) { + Utf8 charSequence250; + Object oldString250 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(250); + if (oldString250 instanceof Utf8) { + charSequence250 = (decoder).readString(((Utf8) oldString250)); + } else { + charSequence250 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(250, charSequence250); + } else { + throw new RuntimeException(("Illegal union index for 'F250': "+ unionIndex250)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex251 = (decoder.readIndex()); + if (unionIndex251 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(251, null); + } else { + if (unionIndex251 == 1) { + Utf8 charSequence251; + Object oldString251 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(251); + if (oldString251 instanceof Utf8) { + charSequence251 = (decoder).readString(((Utf8) oldString251)); + } else { + charSequence251 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(251, charSequence251); + } else { + throw new RuntimeException(("Illegal union index for 'F251': "+ unionIndex251)); + } + } + int unionIndex252 = (decoder.readIndex()); + if (unionIndex252 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(252, null); + } else { + if (unionIndex252 == 1) { + Utf8 charSequence252; + Object oldString252 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(252); + if (oldString252 instanceof Utf8) { + charSequence252 = (decoder).readString(((Utf8) oldString252)); + } else { + charSequence252 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(252, charSequence252); + } else { + throw new RuntimeException(("Illegal union index for 'F252': "+ unionIndex252)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex253 = (decoder.readIndex()); + if (unionIndex253 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(253, null); + } else { + if (unionIndex253 == 1) { + Utf8 charSequence253; + Object oldString253 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(253); + if (oldString253 instanceof Utf8) { + charSequence253 = (decoder).readString(((Utf8) oldString253)); + } else { + charSequence253 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(253, charSequence253); + } else { + throw new RuntimeException(("Illegal union index for 'F253': "+ unionIndex253)); + } + } + int unionIndex254 = (decoder.readIndex()); + if (unionIndex254 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(254, null); + } else { + if (unionIndex254 == 1) { + Utf8 charSequence254; + Object oldString254 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(254); + if (oldString254 instanceof Utf8) { + charSequence254 = (decoder).readString(((Utf8) oldString254)); + } else { + charSequence254 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(254, charSequence254); + } else { + throw new RuntimeException(("Illegal union index for 'F254': "+ unionIndex254)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex255 = (decoder.readIndex()); + if (unionIndex255 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(255, null); + } else { + if (unionIndex255 == 1) { + Utf8 charSequence255; + Object oldString255 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(255); + if (oldString255 instanceof Utf8) { + charSequence255 = (decoder).readString(((Utf8) oldString255)); + } else { + charSequence255 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(255, charSequence255); + } else { + throw new RuntimeException(("Illegal union index for 'F255': "+ unionIndex255)); + } + } + int unionIndex256 = (decoder.readIndex()); + if (unionIndex256 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(256, null); + } else { + if (unionIndex256 == 1) { + Utf8 charSequence256; + Object oldString256 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(256); + if (oldString256 instanceof Utf8) { + charSequence256 = (decoder).readString(((Utf8) oldString256)); + } else { + charSequence256 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(256, charSequence256); + } else { + throw new RuntimeException(("Illegal union index for 'F256': "+ unionIndex256)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex257 = (decoder.readIndex()); + if (unionIndex257 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(257, null); + } else { + if (unionIndex257 == 1) { + Utf8 charSequence257; + Object oldString257 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(257); + if (oldString257 instanceof Utf8) { + charSequence257 = (decoder).readString(((Utf8) oldString257)); + } else { + charSequence257 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(257, charSequence257); + } else { + throw new RuntimeException(("Illegal union index for 'F257': "+ unionIndex257)); + } + } + int unionIndex258 = (decoder.readIndex()); + if (unionIndex258 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(258, null); + } else { + if (unionIndex258 == 1) { + Utf8 charSequence258; + Object oldString258 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(258); + if (oldString258 instanceof Utf8) { + charSequence258 = (decoder).readString(((Utf8) oldString258)); + } else { + charSequence258 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(258, charSequence258); + } else { + throw new RuntimeException(("Illegal union index for 'F258': "+ unionIndex258)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex259 = (decoder.readIndex()); + if (unionIndex259 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(259, null); + } else { + if (unionIndex259 == 1) { + Utf8 charSequence259; + Object oldString259 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(259); + if (oldString259 instanceof Utf8) { + charSequence259 = (decoder).readString(((Utf8) oldString259)); + } else { + charSequence259 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(259, charSequence259); + } else { + throw new RuntimeException(("Illegal union index for 'F259': "+ unionIndex259)); + } + } + int unionIndex260 = (decoder.readIndex()); + if (unionIndex260 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(260, null); + } else { + if (unionIndex260 == 1) { + Utf8 charSequence260; + Object oldString260 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(260); + if (oldString260 instanceof Utf8) { + charSequence260 = (decoder).readString(((Utf8) oldString260)); + } else { + charSequence260 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(260, charSequence260); + } else { + throw new RuntimeException(("Illegal union index for 'F260': "+ unionIndex260)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex261 = (decoder.readIndex()); + if (unionIndex261 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(261, null); + } else { + if (unionIndex261 == 1) { + Utf8 charSequence261; + Object oldString261 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(261); + if (oldString261 instanceof Utf8) { + charSequence261 = (decoder).readString(((Utf8) oldString261)); + } else { + charSequence261 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(261, charSequence261); + } else { + throw new RuntimeException(("Illegal union index for 'F261': "+ unionIndex261)); + } + } + int unionIndex262 = (decoder.readIndex()); + if (unionIndex262 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(262, null); + } else { + if (unionIndex262 == 1) { + Utf8 charSequence262; + Object oldString262 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(262); + if (oldString262 instanceof Utf8) { + charSequence262 = (decoder).readString(((Utf8) oldString262)); + } else { + charSequence262 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(262, charSequence262); + } else { + throw new RuntimeException(("Illegal union index for 'F262': "+ unionIndex262)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex263 = (decoder.readIndex()); + if (unionIndex263 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(263, null); + } else { + if (unionIndex263 == 1) { + Utf8 charSequence263; + Object oldString263 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(263); + if (oldString263 instanceof Utf8) { + charSequence263 = (decoder).readString(((Utf8) oldString263)); + } else { + charSequence263 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(263, charSequence263); + } else { + throw new RuntimeException(("Illegal union index for 'F263': "+ unionIndex263)); + } + } + int unionIndex264 = (decoder.readIndex()); + if (unionIndex264 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(264, null); + } else { + if (unionIndex264 == 1) { + Utf8 charSequence264; + Object oldString264 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(264); + if (oldString264 instanceof Utf8) { + charSequence264 = (decoder).readString(((Utf8) oldString264)); + } else { + charSequence264 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(264, charSequence264); + } else { + throw new RuntimeException(("Illegal union index for 'F264': "+ unionIndex264)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex265 = (decoder.readIndex()); + if (unionIndex265 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(265, null); + } else { + if (unionIndex265 == 1) { + Utf8 charSequence265; + Object oldString265 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(265); + if (oldString265 instanceof Utf8) { + charSequence265 = (decoder).readString(((Utf8) oldString265)); + } else { + charSequence265 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(265, charSequence265); + } else { + throw new RuntimeException(("Illegal union index for 'F265': "+ unionIndex265)); + } + } + int unionIndex266 = (decoder.readIndex()); + if (unionIndex266 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(266, null); + } else { + if (unionIndex266 == 1) { + Utf8 charSequence266; + Object oldString266 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(266); + if (oldString266 instanceof Utf8) { + charSequence266 = (decoder).readString(((Utf8) oldString266)); + } else { + charSequence266 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(266, charSequence266); + } else { + throw new RuntimeException(("Illegal union index for 'F266': "+ unionIndex266)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex267 = (decoder.readIndex()); + if (unionIndex267 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(267, null); + } else { + if (unionIndex267 == 1) { + Utf8 charSequence267; + Object oldString267 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(267); + if (oldString267 instanceof Utf8) { + charSequence267 = (decoder).readString(((Utf8) oldString267)); + } else { + charSequence267 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(267, charSequence267); + } else { + throw new RuntimeException(("Illegal union index for 'F267': "+ unionIndex267)); + } + } + int unionIndex268 = (decoder.readIndex()); + if (unionIndex268 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(268, null); + } else { + if (unionIndex268 == 1) { + Utf8 charSequence268; + Object oldString268 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(268); + if (oldString268 instanceof Utf8) { + charSequence268 = (decoder).readString(((Utf8) oldString268)); + } else { + charSequence268 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(268, charSequence268); + } else { + throw new RuntimeException(("Illegal union index for 'F268': "+ unionIndex268)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex269 = (decoder.readIndex()); + if (unionIndex269 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(269, null); + } else { + if (unionIndex269 == 1) { + Utf8 charSequence269; + Object oldString269 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(269); + if (oldString269 instanceof Utf8) { + charSequence269 = (decoder).readString(((Utf8) oldString269)); + } else { + charSequence269 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(269, charSequence269); + } else { + throw new RuntimeException(("Illegal union index for 'F269': "+ unionIndex269)); + } + } + int unionIndex270 = (decoder.readIndex()); + if (unionIndex270 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(270, null); + } else { + if (unionIndex270 == 1) { + Utf8 charSequence270; + Object oldString270 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(270); + if (oldString270 instanceof Utf8) { + charSequence270 = (decoder).readString(((Utf8) oldString270)); + } else { + charSequence270 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(270, charSequence270); + } else { + throw new RuntimeException(("Illegal union index for 'F270': "+ unionIndex270)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex271 = (decoder.readIndex()); + if (unionIndex271 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(271, null); + } else { + if (unionIndex271 == 1) { + Utf8 charSequence271; + Object oldString271 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(271); + if (oldString271 instanceof Utf8) { + charSequence271 = (decoder).readString(((Utf8) oldString271)); + } else { + charSequence271 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(271, charSequence271); + } else { + throw new RuntimeException(("Illegal union index for 'F271': "+ unionIndex271)); + } + } + int unionIndex272 = (decoder.readIndex()); + if (unionIndex272 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(272, null); + } else { + if (unionIndex272 == 1) { + Utf8 charSequence272; + Object oldString272 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(272); + if (oldString272 instanceof Utf8) { + charSequence272 = (decoder).readString(((Utf8) oldString272)); + } else { + charSequence272 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(272, charSequence272); + } else { + throw new RuntimeException(("Illegal union index for 'F272': "+ unionIndex272)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex273 = (decoder.readIndex()); + if (unionIndex273 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(273, null); + } else { + if (unionIndex273 == 1) { + Utf8 charSequence273; + Object oldString273 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(273); + if (oldString273 instanceof Utf8) { + charSequence273 = (decoder).readString(((Utf8) oldString273)); + } else { + charSequence273 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(273, charSequence273); + } else { + throw new RuntimeException(("Illegal union index for 'F273': "+ unionIndex273)); + } + } + int unionIndex274 = (decoder.readIndex()); + if (unionIndex274 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(274, null); + } else { + if (unionIndex274 == 1) { + Utf8 charSequence274; + Object oldString274 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(274); + if (oldString274 instanceof Utf8) { + charSequence274 = (decoder).readString(((Utf8) oldString274)); + } else { + charSequence274 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(274, charSequence274); + } else { + throw new RuntimeException(("Illegal union index for 'F274': "+ unionIndex274)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex275 = (decoder.readIndex()); + if (unionIndex275 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(275, null); + } else { + if (unionIndex275 == 1) { + Utf8 charSequence275; + Object oldString275 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(275); + if (oldString275 instanceof Utf8) { + charSequence275 = (decoder).readString(((Utf8) oldString275)); + } else { + charSequence275 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(275, charSequence275); + } else { + throw new RuntimeException(("Illegal union index for 'F275': "+ unionIndex275)); + } + } + int unionIndex276 = (decoder.readIndex()); + if (unionIndex276 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(276, null); + } else { + if (unionIndex276 == 1) { + Utf8 charSequence276; + Object oldString276 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(276); + if (oldString276 instanceof Utf8) { + charSequence276 = (decoder).readString(((Utf8) oldString276)); + } else { + charSequence276 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(276, charSequence276); + } else { + throw new RuntimeException(("Illegal union index for 'F276': "+ unionIndex276)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex277 = (decoder.readIndex()); + if (unionIndex277 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(277, null); + } else { + if (unionIndex277 == 1) { + Utf8 charSequence277; + Object oldString277 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(277); + if (oldString277 instanceof Utf8) { + charSequence277 = (decoder).readString(((Utf8) oldString277)); + } else { + charSequence277 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(277, charSequence277); + } else { + throw new RuntimeException(("Illegal union index for 'F277': "+ unionIndex277)); + } + } + int unionIndex278 = (decoder.readIndex()); + if (unionIndex278 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(278, null); + } else { + if (unionIndex278 == 1) { + Utf8 charSequence278; + Object oldString278 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(278); + if (oldString278 instanceof Utf8) { + charSequence278 = (decoder).readString(((Utf8) oldString278)); + } else { + charSequence278 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(278, charSequence278); + } else { + throw new RuntimeException(("Illegal union index for 'F278': "+ unionIndex278)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex279 = (decoder.readIndex()); + if (unionIndex279 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(279, null); + } else { + if (unionIndex279 == 1) { + Utf8 charSequence279; + Object oldString279 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(279); + if (oldString279 instanceof Utf8) { + charSequence279 = (decoder).readString(((Utf8) oldString279)); + } else { + charSequence279 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(279, charSequence279); + } else { + throw new RuntimeException(("Illegal union index for 'F279': "+ unionIndex279)); + } + } + int unionIndex280 = (decoder.readIndex()); + if (unionIndex280 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(280, null); + } else { + if (unionIndex280 == 1) { + Utf8 charSequence280; + Object oldString280 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(280); + if (oldString280 instanceof Utf8) { + charSequence280 = (decoder).readString(((Utf8) oldString280)); + } else { + charSequence280 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(280, charSequence280); + } else { + throw new RuntimeException(("Illegal union index for 'F280': "+ unionIndex280)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex281 = (decoder.readIndex()); + if (unionIndex281 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(281, null); + } else { + if (unionIndex281 == 1) { + Utf8 charSequence281; + Object oldString281 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(281); + if (oldString281 instanceof Utf8) { + charSequence281 = (decoder).readString(((Utf8) oldString281)); + } else { + charSequence281 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(281, charSequence281); + } else { + throw new RuntimeException(("Illegal union index for 'F281': "+ unionIndex281)); + } + } + int unionIndex282 = (decoder.readIndex()); + if (unionIndex282 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(282, null); + } else { + if (unionIndex282 == 1) { + Utf8 charSequence282; + Object oldString282 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(282); + if (oldString282 instanceof Utf8) { + charSequence282 = (decoder).readString(((Utf8) oldString282)); + } else { + charSequence282 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(282, charSequence282); + } else { + throw new RuntimeException(("Illegal union index for 'F282': "+ unionIndex282)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex283 = (decoder.readIndex()); + if (unionIndex283 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(283, null); + } else { + if (unionIndex283 == 1) { + Utf8 charSequence283; + Object oldString283 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(283); + if (oldString283 instanceof Utf8) { + charSequence283 = (decoder).readString(((Utf8) oldString283)); + } else { + charSequence283 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(283, charSequence283); + } else { + throw new RuntimeException(("Illegal union index for 'F283': "+ unionIndex283)); + } + } + int unionIndex284 = (decoder.readIndex()); + if (unionIndex284 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(284, null); + } else { + if (unionIndex284 == 1) { + Utf8 charSequence284; + Object oldString284 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(284); + if (oldString284 instanceof Utf8) { + charSequence284 = (decoder).readString(((Utf8) oldString284)); + } else { + charSequence284 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(284, charSequence284); + } else { + throw new RuntimeException(("Illegal union index for 'F284': "+ unionIndex284)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex285 = (decoder.readIndex()); + if (unionIndex285 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(285, null); + } else { + if (unionIndex285 == 1) { + Utf8 charSequence285; + Object oldString285 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(285); + if (oldString285 instanceof Utf8) { + charSequence285 = (decoder).readString(((Utf8) oldString285)); + } else { + charSequence285 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(285, charSequence285); + } else { + throw new RuntimeException(("Illegal union index for 'F285': "+ unionIndex285)); + } + } + int unionIndex286 = (decoder.readIndex()); + if (unionIndex286 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(286, null); + } else { + if (unionIndex286 == 1) { + Utf8 charSequence286; + Object oldString286 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(286); + if (oldString286 instanceof Utf8) { + charSequence286 = (decoder).readString(((Utf8) oldString286)); + } else { + charSequence286 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(286, charSequence286); + } else { + throw new RuntimeException(("Illegal union index for 'F286': "+ unionIndex286)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex287 = (decoder.readIndex()); + if (unionIndex287 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(287, null); + } else { + if (unionIndex287 == 1) { + Utf8 charSequence287; + Object oldString287 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(287); + if (oldString287 instanceof Utf8) { + charSequence287 = (decoder).readString(((Utf8) oldString287)); + } else { + charSequence287 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(287, charSequence287); + } else { + throw new RuntimeException(("Illegal union index for 'F287': "+ unionIndex287)); + } + } + int unionIndex288 = (decoder.readIndex()); + if (unionIndex288 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(288, null); + } else { + if (unionIndex288 == 1) { + Utf8 charSequence288; + Object oldString288 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(288); + if (oldString288 instanceof Utf8) { + charSequence288 = (decoder).readString(((Utf8) oldString288)); + } else { + charSequence288 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(288, charSequence288); + } else { + throw new RuntimeException(("Illegal union index for 'F288': "+ unionIndex288)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex289 = (decoder.readIndex()); + if (unionIndex289 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(289, null); + } else { + if (unionIndex289 == 1) { + Utf8 charSequence289; + Object oldString289 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(289); + if (oldString289 instanceof Utf8) { + charSequence289 = (decoder).readString(((Utf8) oldString289)); + } else { + charSequence289 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(289, charSequence289); + } else { + throw new RuntimeException(("Illegal union index for 'F289': "+ unionIndex289)); + } + } + int unionIndex290 = (decoder.readIndex()); + if (unionIndex290 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(290, null); + } else { + if (unionIndex290 == 1) { + Utf8 charSequence290; + Object oldString290 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(290); + if (oldString290 instanceof Utf8) { + charSequence290 = (decoder).readString(((Utf8) oldString290)); + } else { + charSequence290 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(290, charSequence290); + } else { + throw new RuntimeException(("Illegal union index for 'F290': "+ unionIndex290)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex291 = (decoder.readIndex()); + if (unionIndex291 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(291, null); + } else { + if (unionIndex291 == 1) { + Utf8 charSequence291; + Object oldString291 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(291); + if (oldString291 instanceof Utf8) { + charSequence291 = (decoder).readString(((Utf8) oldString291)); + } else { + charSequence291 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(291, charSequence291); + } else { + throw new RuntimeException(("Illegal union index for 'F291': "+ unionIndex291)); + } + } + int unionIndex292 = (decoder.readIndex()); + if (unionIndex292 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(292, null); + } else { + if (unionIndex292 == 1) { + Utf8 charSequence292; + Object oldString292 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(292); + if (oldString292 instanceof Utf8) { + charSequence292 = (decoder).readString(((Utf8) oldString292)); + } else { + charSequence292 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(292, charSequence292); + } else { + throw new RuntimeException(("Illegal union index for 'F292': "+ unionIndex292)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex293 = (decoder.readIndex()); + if (unionIndex293 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(293, null); + } else { + if (unionIndex293 == 1) { + Utf8 charSequence293; + Object oldString293 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(293); + if (oldString293 instanceof Utf8) { + charSequence293 = (decoder).readString(((Utf8) oldString293)); + } else { + charSequence293 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(293, charSequence293); + } else { + throw new RuntimeException(("Illegal union index for 'F293': "+ unionIndex293)); + } + } + int unionIndex294 = (decoder.readIndex()); + if (unionIndex294 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(294, null); + } else { + if (unionIndex294 == 1) { + Utf8 charSequence294; + Object oldString294 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(294); + if (oldString294 instanceof Utf8) { + charSequence294 = (decoder).readString(((Utf8) oldString294)); + } else { + charSequence294 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(294, charSequence294); + } else { + throw new RuntimeException(("Illegal union index for 'F294': "+ unionIndex294)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex295 = (decoder.readIndex()); + if (unionIndex295 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(295, null); + } else { + if (unionIndex295 == 1) { + Utf8 charSequence295; + Object oldString295 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(295); + if (oldString295 instanceof Utf8) { + charSequence295 = (decoder).readString(((Utf8) oldString295)); + } else { + charSequence295 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(295, charSequence295); + } else { + throw new RuntimeException(("Illegal union index for 'F295': "+ unionIndex295)); + } + } + int unionIndex296 = (decoder.readIndex()); + if (unionIndex296 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(296, null); + } else { + if (unionIndex296 == 1) { + Utf8 charSequence296; + Object oldString296 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(296); + if (oldString296 instanceof Utf8) { + charSequence296 = (decoder).readString(((Utf8) oldString296)); + } else { + charSequence296 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(296, charSequence296); + } else { + throw new RuntimeException(("Illegal union index for 'F296': "+ unionIndex296)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex297 = (decoder.readIndex()); + if (unionIndex297 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(297, null); + } else { + if (unionIndex297 == 1) { + Utf8 charSequence297; + Object oldString297 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(297); + if (oldString297 instanceof Utf8) { + charSequence297 = (decoder).readString(((Utf8) oldString297)); + } else { + charSequence297 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(297, charSequence297); + } else { + throw new RuntimeException(("Illegal union index for 'F297': "+ unionIndex297)); + } + } + int unionIndex298 = (decoder.readIndex()); + if (unionIndex298 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(298, null); + } else { + if (unionIndex298 == 1) { + Utf8 charSequence298; + Object oldString298 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(298); + if (oldString298 instanceof Utf8) { + charSequence298 = (decoder).readString(((Utf8) oldString298)); + } else { + charSequence298 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(298, charSequence298); + } else { + throw new RuntimeException(("Illegal union index for 'F298': "+ unionIndex298)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex299 = (decoder.readIndex()); + if (unionIndex299 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(299, null); + } else { + if (unionIndex299 == 1) { + Utf8 charSequence299; + Object oldString299 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(299); + if (oldString299 instanceof Utf8) { + charSequence299 = (decoder).readString(((Utf8) oldString299)); + } else { + charSequence299 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(299, charSequence299); + } else { + throw new RuntimeException(("Illegal union index for 'F299': "+ unionIndex299)); + } + } + int unionIndex300 = (decoder.readIndex()); + if (unionIndex300 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(300, null); + } else { + if (unionIndex300 == 1) { + Utf8 charSequence300; + Object oldString300 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(300); + if (oldString300 instanceof Utf8) { + charSequence300 = (decoder).readString(((Utf8) oldString300)); + } else { + charSequence300 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(300, charSequence300); + } else { + throw new RuntimeException(("Illegal union index for 'F300': "+ unionIndex300)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex301 = (decoder.readIndex()); + if (unionIndex301 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(301, null); + } else { + if (unionIndex301 == 1) { + Utf8 charSequence301; + Object oldString301 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(301); + if (oldString301 instanceof Utf8) { + charSequence301 = (decoder).readString(((Utf8) oldString301)); + } else { + charSequence301 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(301, charSequence301); + } else { + throw new RuntimeException(("Illegal union index for 'F301': "+ unionIndex301)); + } + } + int unionIndex302 = (decoder.readIndex()); + if (unionIndex302 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(302, null); + } else { + if (unionIndex302 == 1) { + Utf8 charSequence302; + Object oldString302 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(302); + if (oldString302 instanceof Utf8) { + charSequence302 = (decoder).readString(((Utf8) oldString302)); + } else { + charSequence302 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(302, charSequence302); + } else { + throw new RuntimeException(("Illegal union index for 'F302': "+ unionIndex302)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex303 = (decoder.readIndex()); + if (unionIndex303 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(303, null); + } else { + if (unionIndex303 == 1) { + Utf8 charSequence303; + Object oldString303 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(303); + if (oldString303 instanceof Utf8) { + charSequence303 = (decoder).readString(((Utf8) oldString303)); + } else { + charSequence303 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(303, charSequence303); + } else { + throw new RuntimeException(("Illegal union index for 'F303': "+ unionIndex303)); + } + } + int unionIndex304 = (decoder.readIndex()); + if (unionIndex304 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(304, null); + } else { + if (unionIndex304 == 1) { + Utf8 charSequence304; + Object oldString304 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(304); + if (oldString304 instanceof Utf8) { + charSequence304 = (decoder).readString(((Utf8) oldString304)); + } else { + charSequence304 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(304, charSequence304); + } else { + throw new RuntimeException(("Illegal union index for 'F304': "+ unionIndex304)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex305 = (decoder.readIndex()); + if (unionIndex305 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(305, null); + } else { + if (unionIndex305 == 1) { + Utf8 charSequence305; + Object oldString305 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(305); + if (oldString305 instanceof Utf8) { + charSequence305 = (decoder).readString(((Utf8) oldString305)); + } else { + charSequence305 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(305, charSequence305); + } else { + throw new RuntimeException(("Illegal union index for 'F305': "+ unionIndex305)); + } + } + int unionIndex306 = (decoder.readIndex()); + if (unionIndex306 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(306, null); + } else { + if (unionIndex306 == 1) { + Utf8 charSequence306; + Object oldString306 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(306); + if (oldString306 instanceof Utf8) { + charSequence306 = (decoder).readString(((Utf8) oldString306)); + } else { + charSequence306 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(306, charSequence306); + } else { + throw new RuntimeException(("Illegal union index for 'F306': "+ unionIndex306)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex307 = (decoder.readIndex()); + if (unionIndex307 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(307, null); + } else { + if (unionIndex307 == 1) { + Utf8 charSequence307; + Object oldString307 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(307); + if (oldString307 instanceof Utf8) { + charSequence307 = (decoder).readString(((Utf8) oldString307)); + } else { + charSequence307 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(307, charSequence307); + } else { + throw new RuntimeException(("Illegal union index for 'F307': "+ unionIndex307)); + } + } + int unionIndex308 = (decoder.readIndex()); + if (unionIndex308 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(308, null); + } else { + if (unionIndex308 == 1) { + Utf8 charSequence308; + Object oldString308 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(308); + if (oldString308 instanceof Utf8) { + charSequence308 = (decoder).readString(((Utf8) oldString308)); + } else { + charSequence308 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(308, charSequence308); + } else { + throw new RuntimeException(("Illegal union index for 'F308': "+ unionIndex308)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex309 = (decoder.readIndex()); + if (unionIndex309 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(309, null); + } else { + if (unionIndex309 == 1) { + Utf8 charSequence309; + Object oldString309 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(309); + if (oldString309 instanceof Utf8) { + charSequence309 = (decoder).readString(((Utf8) oldString309)); + } else { + charSequence309 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(309, charSequence309); + } else { + throw new RuntimeException(("Illegal union index for 'F309': "+ unionIndex309)); + } + } + int unionIndex310 = (decoder.readIndex()); + if (unionIndex310 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(310, null); + } else { + if (unionIndex310 == 1) { + Utf8 charSequence310; + Object oldString310 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(310); + if (oldString310 instanceof Utf8) { + charSequence310 = (decoder).readString(((Utf8) oldString310)); + } else { + charSequence310 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(310, charSequence310); + } else { + throw new RuntimeException(("Illegal union index for 'F310': "+ unionIndex310)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex311 = (decoder.readIndex()); + if (unionIndex311 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(311, null); + } else { + if (unionIndex311 == 1) { + Utf8 charSequence311; + Object oldString311 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(311); + if (oldString311 instanceof Utf8) { + charSequence311 = (decoder).readString(((Utf8) oldString311)); + } else { + charSequence311 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(311, charSequence311); + } else { + throw new RuntimeException(("Illegal union index for 'F311': "+ unionIndex311)); + } + } + int unionIndex312 = (decoder.readIndex()); + if (unionIndex312 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(312, null); + } else { + if (unionIndex312 == 1) { + Utf8 charSequence312; + Object oldString312 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(312); + if (oldString312 instanceof Utf8) { + charSequence312 = (decoder).readString(((Utf8) oldString312)); + } else { + charSequence312 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(312, charSequence312); + } else { + throw new RuntimeException(("Illegal union index for 'F312': "+ unionIndex312)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex313 = (decoder.readIndex()); + if (unionIndex313 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(313, null); + } else { + if (unionIndex313 == 1) { + Utf8 charSequence313; + Object oldString313 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(313); + if (oldString313 instanceof Utf8) { + charSequence313 = (decoder).readString(((Utf8) oldString313)); + } else { + charSequence313 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(313, charSequence313); + } else { + throw new RuntimeException(("Illegal union index for 'F313': "+ unionIndex313)); + } + } + int unionIndex314 = (decoder.readIndex()); + if (unionIndex314 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(314, null); + } else { + if (unionIndex314 == 1) { + Utf8 charSequence314; + Object oldString314 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(314); + if (oldString314 instanceof Utf8) { + charSequence314 = (decoder).readString(((Utf8) oldString314)); + } else { + charSequence314 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(314, charSequence314); + } else { + throw new RuntimeException(("Illegal union index for 'F314': "+ unionIndex314)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex315 = (decoder.readIndex()); + if (unionIndex315 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(315, null); + } else { + if (unionIndex315 == 1) { + Utf8 charSequence315; + Object oldString315 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(315); + if (oldString315 instanceof Utf8) { + charSequence315 = (decoder).readString(((Utf8) oldString315)); + } else { + charSequence315 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(315, charSequence315); + } else { + throw new RuntimeException(("Illegal union index for 'F315': "+ unionIndex315)); + } + } + int unionIndex316 = (decoder.readIndex()); + if (unionIndex316 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(316, null); + } else { + if (unionIndex316 == 1) { + Utf8 charSequence316; + Object oldString316 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(316); + if (oldString316 instanceof Utf8) { + charSequence316 = (decoder).readString(((Utf8) oldString316)); + } else { + charSequence316 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(316, charSequence316); + } else { + throw new RuntimeException(("Illegal union index for 'F316': "+ unionIndex316)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex317 = (decoder.readIndex()); + if (unionIndex317 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(317, null); + } else { + if (unionIndex317 == 1) { + Utf8 charSequence317; + Object oldString317 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(317); + if (oldString317 instanceof Utf8) { + charSequence317 = (decoder).readString(((Utf8) oldString317)); + } else { + charSequence317 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(317, charSequence317); + } else { + throw new RuntimeException(("Illegal union index for 'F317': "+ unionIndex317)); + } + } + int unionIndex318 = (decoder.readIndex()); + if (unionIndex318 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(318, null); + } else { + if (unionIndex318 == 1) { + Utf8 charSequence318; + Object oldString318 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(318); + if (oldString318 instanceof Utf8) { + charSequence318 = (decoder).readString(((Utf8) oldString318)); + } else { + charSequence318 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(318, charSequence318); + } else { + throw new RuntimeException(("Illegal union index for 'F318': "+ unionIndex318)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex319 = (decoder.readIndex()); + if (unionIndex319 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(319, null); + } else { + if (unionIndex319 == 1) { + Utf8 charSequence319; + Object oldString319 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(319); + if (oldString319 instanceof Utf8) { + charSequence319 = (decoder).readString(((Utf8) oldString319)); + } else { + charSequence319 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(319, charSequence319); + } else { + throw new RuntimeException(("Illegal union index for 'F319': "+ unionIndex319)); + } + } + int unionIndex320 = (decoder.readIndex()); + if (unionIndex320 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(320, null); + } else { + if (unionIndex320 == 1) { + Utf8 charSequence320; + Object oldString320 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(320); + if (oldString320 instanceof Utf8) { + charSequence320 = (decoder).readString(((Utf8) oldString320)); + } else { + charSequence320 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(320, charSequence320); + } else { + throw new RuntimeException(("Illegal union index for 'F320': "+ unionIndex320)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex321 = (decoder.readIndex()); + if (unionIndex321 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(321, null); + } else { + if (unionIndex321 == 1) { + Utf8 charSequence321; + Object oldString321 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(321); + if (oldString321 instanceof Utf8) { + charSequence321 = (decoder).readString(((Utf8) oldString321)); + } else { + charSequence321 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(321, charSequence321); + } else { + throw new RuntimeException(("Illegal union index for 'F321': "+ unionIndex321)); + } + } + int unionIndex322 = (decoder.readIndex()); + if (unionIndex322 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(322, null); + } else { + if (unionIndex322 == 1) { + Utf8 charSequence322; + Object oldString322 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(322); + if (oldString322 instanceof Utf8) { + charSequence322 = (decoder).readString(((Utf8) oldString322)); + } else { + charSequence322 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(322, charSequence322); + } else { + throw new RuntimeException(("Illegal union index for 'F322': "+ unionIndex322)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex323 = (decoder.readIndex()); + if (unionIndex323 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(323, null); + } else { + if (unionIndex323 == 1) { + Utf8 charSequence323; + Object oldString323 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(323); + if (oldString323 instanceof Utf8) { + charSequence323 = (decoder).readString(((Utf8) oldString323)); + } else { + charSequence323 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(323, charSequence323); + } else { + throw new RuntimeException(("Illegal union index for 'F323': "+ unionIndex323)); + } + } + int unionIndex324 = (decoder.readIndex()); + if (unionIndex324 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(324, null); + } else { + if (unionIndex324 == 1) { + Utf8 charSequence324; + Object oldString324 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(324); + if (oldString324 instanceof Utf8) { + charSequence324 = (decoder).readString(((Utf8) oldString324)); + } else { + charSequence324 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(324, charSequence324); + } else { + throw new RuntimeException(("Illegal union index for 'F324': "+ unionIndex324)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex325 = (decoder.readIndex()); + if (unionIndex325 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(325, null); + } else { + if (unionIndex325 == 1) { + Utf8 charSequence325; + Object oldString325 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(325); + if (oldString325 instanceof Utf8) { + charSequence325 = (decoder).readString(((Utf8) oldString325)); + } else { + charSequence325 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(325, charSequence325); + } else { + throw new RuntimeException(("Illegal union index for 'F325': "+ unionIndex325)); + } + } + int unionIndex326 = (decoder.readIndex()); + if (unionIndex326 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(326, null); + } else { + if (unionIndex326 == 1) { + Utf8 charSequence326; + Object oldString326 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(326); + if (oldString326 instanceof Utf8) { + charSequence326 = (decoder).readString(((Utf8) oldString326)); + } else { + charSequence326 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(326, charSequence326); + } else { + throw new RuntimeException(("Illegal union index for 'F326': "+ unionIndex326)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex327 = (decoder.readIndex()); + if (unionIndex327 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(327, null); + } else { + if (unionIndex327 == 1) { + Utf8 charSequence327; + Object oldString327 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(327); + if (oldString327 instanceof Utf8) { + charSequence327 = (decoder).readString(((Utf8) oldString327)); + } else { + charSequence327 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(327, charSequence327); + } else { + throw new RuntimeException(("Illegal union index for 'F327': "+ unionIndex327)); + } + } + int unionIndex328 = (decoder.readIndex()); + if (unionIndex328 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(328, null); + } else { + if (unionIndex328 == 1) { + Utf8 charSequence328; + Object oldString328 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(328); + if (oldString328 instanceof Utf8) { + charSequence328 = (decoder).readString(((Utf8) oldString328)); + } else { + charSequence328 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(328, charSequence328); + } else { + throw new RuntimeException(("Illegal union index for 'F328': "+ unionIndex328)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex329 = (decoder.readIndex()); + if (unionIndex329 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(329, null); + } else { + if (unionIndex329 == 1) { + Utf8 charSequence329; + Object oldString329 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(329); + if (oldString329 instanceof Utf8) { + charSequence329 = (decoder).readString(((Utf8) oldString329)); + } else { + charSequence329 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(329, charSequence329); + } else { + throw new RuntimeException(("Illegal union index for 'F329': "+ unionIndex329)); + } + } + int unionIndex330 = (decoder.readIndex()); + if (unionIndex330 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(330, null); + } else { + if (unionIndex330 == 1) { + Utf8 charSequence330; + Object oldString330 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(330); + if (oldString330 instanceof Utf8) { + charSequence330 = (decoder).readString(((Utf8) oldString330)); + } else { + charSequence330 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(330, charSequence330); + } else { + throw new RuntimeException(("Illegal union index for 'F330': "+ unionIndex330)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex331 = (decoder.readIndex()); + if (unionIndex331 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(331, null); + } else { + if (unionIndex331 == 1) { + Utf8 charSequence331; + Object oldString331 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(331); + if (oldString331 instanceof Utf8) { + charSequence331 = (decoder).readString(((Utf8) oldString331)); + } else { + charSequence331 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(331, charSequence331); + } else { + throw new RuntimeException(("Illegal union index for 'F331': "+ unionIndex331)); + } + } + int unionIndex332 = (decoder.readIndex()); + if (unionIndex332 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(332, null); + } else { + if (unionIndex332 == 1) { + Utf8 charSequence332; + Object oldString332 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(332); + if (oldString332 instanceof Utf8) { + charSequence332 = (decoder).readString(((Utf8) oldString332)); + } else { + charSequence332 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(332, charSequence332); + } else { + throw new RuntimeException(("Illegal union index for 'F332': "+ unionIndex332)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex333 = (decoder.readIndex()); + if (unionIndex333 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(333, null); + } else { + if (unionIndex333 == 1) { + Utf8 charSequence333; + Object oldString333 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(333); + if (oldString333 instanceof Utf8) { + charSequence333 = (decoder).readString(((Utf8) oldString333)); + } else { + charSequence333 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(333, charSequence333); + } else { + throw new RuntimeException(("Illegal union index for 'F333': "+ unionIndex333)); + } + } + int unionIndex334 = (decoder.readIndex()); + if (unionIndex334 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(334, null); + } else { + if (unionIndex334 == 1) { + Utf8 charSequence334; + Object oldString334 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(334); + if (oldString334 instanceof Utf8) { + charSequence334 = (decoder).readString(((Utf8) oldString334)); + } else { + charSequence334 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(334, charSequence334); + } else { + throw new RuntimeException(("Illegal union index for 'F334': "+ unionIndex334)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex335 = (decoder.readIndex()); + if (unionIndex335 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(335, null); + } else { + if (unionIndex335 == 1) { + Utf8 charSequence335; + Object oldString335 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(335); + if (oldString335 instanceof Utf8) { + charSequence335 = (decoder).readString(((Utf8) oldString335)); + } else { + charSequence335 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(335, charSequence335); + } else { + throw new RuntimeException(("Illegal union index for 'F335': "+ unionIndex335)); + } + } + int unionIndex336 = (decoder.readIndex()); + if (unionIndex336 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(336, null); + } else { + if (unionIndex336 == 1) { + Utf8 charSequence336; + Object oldString336 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(336); + if (oldString336 instanceof Utf8) { + charSequence336 = (decoder).readString(((Utf8) oldString336)); + } else { + charSequence336 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(336, charSequence336); + } else { + throw new RuntimeException(("Illegal union index for 'F336': "+ unionIndex336)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex337 = (decoder.readIndex()); + if (unionIndex337 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(337, null); + } else { + if (unionIndex337 == 1) { + Utf8 charSequence337; + Object oldString337 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(337); + if (oldString337 instanceof Utf8) { + charSequence337 = (decoder).readString(((Utf8) oldString337)); + } else { + charSequence337 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(337, charSequence337); + } else { + throw new RuntimeException(("Illegal union index for 'F337': "+ unionIndex337)); + } + } + int unionIndex338 = (decoder.readIndex()); + if (unionIndex338 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(338, null); + } else { + if (unionIndex338 == 1) { + Utf8 charSequence338; + Object oldString338 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(338); + if (oldString338 instanceof Utf8) { + charSequence338 = (decoder).readString(((Utf8) oldString338)); + } else { + charSequence338 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(338, charSequence338); + } else { + throw new RuntimeException(("Illegal union index for 'F338': "+ unionIndex338)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex339 = (decoder.readIndex()); + if (unionIndex339 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(339, null); + } else { + if (unionIndex339 == 1) { + Utf8 charSequence339; + Object oldString339 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(339); + if (oldString339 instanceof Utf8) { + charSequence339 = (decoder).readString(((Utf8) oldString339)); + } else { + charSequence339 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(339, charSequence339); + } else { + throw new RuntimeException(("Illegal union index for 'F339': "+ unionIndex339)); + } + } + int unionIndex340 = (decoder.readIndex()); + if (unionIndex340 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(340, null); + } else { + if (unionIndex340 == 1) { + Utf8 charSequence340; + Object oldString340 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(340); + if (oldString340 instanceof Utf8) { + charSequence340 = (decoder).readString(((Utf8) oldString340)); + } else { + charSequence340 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(340, charSequence340); + } else { + throw new RuntimeException(("Illegal union index for 'F340': "+ unionIndex340)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex341 = (decoder.readIndex()); + if (unionIndex341 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(341, null); + } else { + if (unionIndex341 == 1) { + Utf8 charSequence341; + Object oldString341 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(341); + if (oldString341 instanceof Utf8) { + charSequence341 = (decoder).readString(((Utf8) oldString341)); + } else { + charSequence341 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(341, charSequence341); + } else { + throw new RuntimeException(("Illegal union index for 'F341': "+ unionIndex341)); + } + } + int unionIndex342 = (decoder.readIndex()); + if (unionIndex342 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(342, null); + } else { + if (unionIndex342 == 1) { + Utf8 charSequence342; + Object oldString342 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(342); + if (oldString342 instanceof Utf8) { + charSequence342 = (decoder).readString(((Utf8) oldString342)); + } else { + charSequence342 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(342, charSequence342); + } else { + throw new RuntimeException(("Illegal union index for 'F342': "+ unionIndex342)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex343 = (decoder.readIndex()); + if (unionIndex343 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(343, null); + } else { + if (unionIndex343 == 1) { + Utf8 charSequence343; + Object oldString343 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(343); + if (oldString343 instanceof Utf8) { + charSequence343 = (decoder).readString(((Utf8) oldString343)); + } else { + charSequence343 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(343, charSequence343); + } else { + throw new RuntimeException(("Illegal union index for 'F343': "+ unionIndex343)); + } + } + int unionIndex344 = (decoder.readIndex()); + if (unionIndex344 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(344, null); + } else { + if (unionIndex344 == 1) { + Utf8 charSequence344; + Object oldString344 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(344); + if (oldString344 instanceof Utf8) { + charSequence344 = (decoder).readString(((Utf8) oldString344)); + } else { + charSequence344 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(344, charSequence344); + } else { + throw new RuntimeException(("Illegal union index for 'F344': "+ unionIndex344)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex345 = (decoder.readIndex()); + if (unionIndex345 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(345, null); + } else { + if (unionIndex345 == 1) { + Utf8 charSequence345; + Object oldString345 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(345); + if (oldString345 instanceof Utf8) { + charSequence345 = (decoder).readString(((Utf8) oldString345)); + } else { + charSequence345 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(345, charSequence345); + } else { + throw new RuntimeException(("Illegal union index for 'F345': "+ unionIndex345)); + } + } + int unionIndex346 = (decoder.readIndex()); + if (unionIndex346 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(346, null); + } else { + if (unionIndex346 == 1) { + Utf8 charSequence346; + Object oldString346 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(346); + if (oldString346 instanceof Utf8) { + charSequence346 = (decoder).readString(((Utf8) oldString346)); + } else { + charSequence346 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(346, charSequence346); + } else { + throw new RuntimeException(("Illegal union index for 'F346': "+ unionIndex346)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex347 = (decoder.readIndex()); + if (unionIndex347 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(347, null); + } else { + if (unionIndex347 == 1) { + Utf8 charSequence347; + Object oldString347 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(347); + if (oldString347 instanceof Utf8) { + charSequence347 = (decoder).readString(((Utf8) oldString347)); + } else { + charSequence347 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(347, charSequence347); + } else { + throw new RuntimeException(("Illegal union index for 'F347': "+ unionIndex347)); + } + } + int unionIndex348 = (decoder.readIndex()); + if (unionIndex348 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(348, null); + } else { + if (unionIndex348 == 1) { + Utf8 charSequence348; + Object oldString348 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(348); + if (oldString348 instanceof Utf8) { + charSequence348 = (decoder).readString(((Utf8) oldString348)); + } else { + charSequence348 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(348, charSequence348); + } else { + throw new RuntimeException(("Illegal union index for 'F348': "+ unionIndex348)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex349 = (decoder.readIndex()); + if (unionIndex349 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(349, null); + } else { + if (unionIndex349 == 1) { + Utf8 charSequence349; + Object oldString349 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(349); + if (oldString349 instanceof Utf8) { + charSequence349 = (decoder).readString(((Utf8) oldString349)); + } else { + charSequence349 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(349, charSequence349); + } else { + throw new RuntimeException(("Illegal union index for 'F349': "+ unionIndex349)); + } + } + int unionIndex350 = (decoder.readIndex()); + if (unionIndex350 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(350, null); + } else { + if (unionIndex350 == 1) { + Utf8 charSequence350; + Object oldString350 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(350); + if (oldString350 instanceof Utf8) { + charSequence350 = (decoder).readString(((Utf8) oldString350)); + } else { + charSequence350 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(350, charSequence350); + } else { + throw new RuntimeException(("Illegal union index for 'F350': "+ unionIndex350)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex351 = (decoder.readIndex()); + if (unionIndex351 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(351, null); + } else { + if (unionIndex351 == 1) { + Utf8 charSequence351; + Object oldString351 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(351); + if (oldString351 instanceof Utf8) { + charSequence351 = (decoder).readString(((Utf8) oldString351)); + } else { + charSequence351 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(351, charSequence351); + } else { + throw new RuntimeException(("Illegal union index for 'F351': "+ unionIndex351)); + } + } + int unionIndex352 = (decoder.readIndex()); + if (unionIndex352 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(352, null); + } else { + if (unionIndex352 == 1) { + Utf8 charSequence352; + Object oldString352 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(352); + if (oldString352 instanceof Utf8) { + charSequence352 = (decoder).readString(((Utf8) oldString352)); + } else { + charSequence352 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(352, charSequence352); + } else { + throw new RuntimeException(("Illegal union index for 'F352': "+ unionIndex352)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex353 = (decoder.readIndex()); + if (unionIndex353 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(353, null); + } else { + if (unionIndex353 == 1) { + Utf8 charSequence353; + Object oldString353 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(353); + if (oldString353 instanceof Utf8) { + charSequence353 = (decoder).readString(((Utf8) oldString353)); + } else { + charSequence353 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(353, charSequence353); + } else { + throw new RuntimeException(("Illegal union index for 'F353': "+ unionIndex353)); + } + } + int unionIndex354 = (decoder.readIndex()); + if (unionIndex354 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(354, null); + } else { + if (unionIndex354 == 1) { + Utf8 charSequence354; + Object oldString354 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(354); + if (oldString354 instanceof Utf8) { + charSequence354 = (decoder).readString(((Utf8) oldString354)); + } else { + charSequence354 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(354, charSequence354); + } else { + throw new RuntimeException(("Illegal union index for 'F354': "+ unionIndex354)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex355 = (decoder.readIndex()); + if (unionIndex355 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(355, null); + } else { + if (unionIndex355 == 1) { + Utf8 charSequence355; + Object oldString355 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(355); + if (oldString355 instanceof Utf8) { + charSequence355 = (decoder).readString(((Utf8) oldString355)); + } else { + charSequence355 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(355, charSequence355); + } else { + throw new RuntimeException(("Illegal union index for 'F355': "+ unionIndex355)); + } + } + int unionIndex356 = (decoder.readIndex()); + if (unionIndex356 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(356, null); + } else { + if (unionIndex356 == 1) { + Utf8 charSequence356; + Object oldString356 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(356); + if (oldString356 instanceof Utf8) { + charSequence356 = (decoder).readString(((Utf8) oldString356)); + } else { + charSequence356 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(356, charSequence356); + } else { + throw new RuntimeException(("Illegal union index for 'F356': "+ unionIndex356)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex357 = (decoder.readIndex()); + if (unionIndex357 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(357, null); + } else { + if (unionIndex357 == 1) { + Utf8 charSequence357; + Object oldString357 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(357); + if (oldString357 instanceof Utf8) { + charSequence357 = (decoder).readString(((Utf8) oldString357)); + } else { + charSequence357 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(357, charSequence357); + } else { + throw new RuntimeException(("Illegal union index for 'F357': "+ unionIndex357)); + } + } + int unionIndex358 = (decoder.readIndex()); + if (unionIndex358 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(358, null); + } else { + if (unionIndex358 == 1) { + Utf8 charSequence358; + Object oldString358 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(358); + if (oldString358 instanceof Utf8) { + charSequence358 = (decoder).readString(((Utf8) oldString358)); + } else { + charSequence358 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(358, charSequence358); + } else { + throw new RuntimeException(("Illegal union index for 'F358': "+ unionIndex358)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex359 = (decoder.readIndex()); + if (unionIndex359 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(359, null); + } else { + if (unionIndex359 == 1) { + Utf8 charSequence359; + Object oldString359 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(359); + if (oldString359 instanceof Utf8) { + charSequence359 = (decoder).readString(((Utf8) oldString359)); + } else { + charSequence359 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(359, charSequence359); + } else { + throw new RuntimeException(("Illegal union index for 'F359': "+ unionIndex359)); + } + } + int unionIndex360 = (decoder.readIndex()); + if (unionIndex360 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(360, null); + } else { + if (unionIndex360 == 1) { + Utf8 charSequence360; + Object oldString360 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(360); + if (oldString360 instanceof Utf8) { + charSequence360 = (decoder).readString(((Utf8) oldString360)); + } else { + charSequence360 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(360, charSequence360); + } else { + throw new RuntimeException(("Illegal union index for 'F360': "+ unionIndex360)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex361 = (decoder.readIndex()); + if (unionIndex361 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(361, null); + } else { + if (unionIndex361 == 1) { + Utf8 charSequence361; + Object oldString361 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(361); + if (oldString361 instanceof Utf8) { + charSequence361 = (decoder).readString(((Utf8) oldString361)); + } else { + charSequence361 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(361, charSequence361); + } else { + throw new RuntimeException(("Illegal union index for 'F361': "+ unionIndex361)); + } + } + int unionIndex362 = (decoder.readIndex()); + if (unionIndex362 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(362, null); + } else { + if (unionIndex362 == 1) { + Utf8 charSequence362; + Object oldString362 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(362); + if (oldString362 instanceof Utf8) { + charSequence362 = (decoder).readString(((Utf8) oldString362)); + } else { + charSequence362 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(362, charSequence362); + } else { + throw new RuntimeException(("Illegal union index for 'F362': "+ unionIndex362)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex363 = (decoder.readIndex()); + if (unionIndex363 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(363, null); + } else { + if (unionIndex363 == 1) { + Utf8 charSequence363; + Object oldString363 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(363); + if (oldString363 instanceof Utf8) { + charSequence363 = (decoder).readString(((Utf8) oldString363)); + } else { + charSequence363 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(363, charSequence363); + } else { + throw new RuntimeException(("Illegal union index for 'F363': "+ unionIndex363)); + } + } + int unionIndex364 = (decoder.readIndex()); + if (unionIndex364 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(364, null); + } else { + if (unionIndex364 == 1) { + Utf8 charSequence364; + Object oldString364 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(364); + if (oldString364 instanceof Utf8) { + charSequence364 = (decoder).readString(((Utf8) oldString364)); + } else { + charSequence364 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(364, charSequence364); + } else { + throw new RuntimeException(("Illegal union index for 'F364': "+ unionIndex364)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex365 = (decoder.readIndex()); + if (unionIndex365 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(365, null); + } else { + if (unionIndex365 == 1) { + Utf8 charSequence365; + Object oldString365 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(365); + if (oldString365 instanceof Utf8) { + charSequence365 = (decoder).readString(((Utf8) oldString365)); + } else { + charSequence365 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(365, charSequence365); + } else { + throw new RuntimeException(("Illegal union index for 'F365': "+ unionIndex365)); + } + } + int unionIndex366 = (decoder.readIndex()); + if (unionIndex366 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(366, null); + } else { + if (unionIndex366 == 1) { + Utf8 charSequence366; + Object oldString366 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(366); + if (oldString366 instanceof Utf8) { + charSequence366 = (decoder).readString(((Utf8) oldString366)); + } else { + charSequence366 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(366, charSequence366); + } else { + throw new RuntimeException(("Illegal union index for 'F366': "+ unionIndex366)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex367 = (decoder.readIndex()); + if (unionIndex367 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(367, null); + } else { + if (unionIndex367 == 1) { + Utf8 charSequence367; + Object oldString367 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(367); + if (oldString367 instanceof Utf8) { + charSequence367 = (decoder).readString(((Utf8) oldString367)); + } else { + charSequence367 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(367, charSequence367); + } else { + throw new RuntimeException(("Illegal union index for 'F367': "+ unionIndex367)); + } + } + int unionIndex368 = (decoder.readIndex()); + if (unionIndex368 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(368, null); + } else { + if (unionIndex368 == 1) { + Utf8 charSequence368; + Object oldString368 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(368); + if (oldString368 instanceof Utf8) { + charSequence368 = (decoder).readString(((Utf8) oldString368)); + } else { + charSequence368 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(368, charSequence368); + } else { + throw new RuntimeException(("Illegal union index for 'F368': "+ unionIndex368)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex369 = (decoder.readIndex()); + if (unionIndex369 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(369, null); + } else { + if (unionIndex369 == 1) { + Utf8 charSequence369; + Object oldString369 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(369); + if (oldString369 instanceof Utf8) { + charSequence369 = (decoder).readString(((Utf8) oldString369)); + } else { + charSequence369 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(369, charSequence369); + } else { + throw new RuntimeException(("Illegal union index for 'F369': "+ unionIndex369)); + } + } + int unionIndex370 = (decoder.readIndex()); + if (unionIndex370 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(370, null); + } else { + if (unionIndex370 == 1) { + Utf8 charSequence370; + Object oldString370 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(370); + if (oldString370 instanceof Utf8) { + charSequence370 = (decoder).readString(((Utf8) oldString370)); + } else { + charSequence370 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(370, charSequence370); + } else { + throw new RuntimeException(("Illegal union index for 'F370': "+ unionIndex370)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex371 = (decoder.readIndex()); + if (unionIndex371 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(371, null); + } else { + if (unionIndex371 == 1) { + Utf8 charSequence371; + Object oldString371 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(371); + if (oldString371 instanceof Utf8) { + charSequence371 = (decoder).readString(((Utf8) oldString371)); + } else { + charSequence371 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(371, charSequence371); + } else { + throw new RuntimeException(("Illegal union index for 'F371': "+ unionIndex371)); + } + } + int unionIndex372 = (decoder.readIndex()); + if (unionIndex372 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(372, null); + } else { + if (unionIndex372 == 1) { + Utf8 charSequence372; + Object oldString372 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(372); + if (oldString372 instanceof Utf8) { + charSequence372 = (decoder).readString(((Utf8) oldString372)); + } else { + charSequence372 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(372, charSequence372); + } else { + throw new RuntimeException(("Illegal union index for 'F372': "+ unionIndex372)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex373 = (decoder.readIndex()); + if (unionIndex373 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(373, null); + } else { + if (unionIndex373 == 1) { + Utf8 charSequence373; + Object oldString373 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(373); + if (oldString373 instanceof Utf8) { + charSequence373 = (decoder).readString(((Utf8) oldString373)); + } else { + charSequence373 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(373, charSequence373); + } else { + throw new RuntimeException(("Illegal union index for 'F373': "+ unionIndex373)); + } + } + int unionIndex374 = (decoder.readIndex()); + if (unionIndex374 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(374, null); + } else { + if (unionIndex374 == 1) { + Utf8 charSequence374; + Object oldString374 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(374); + if (oldString374 instanceof Utf8) { + charSequence374 = (decoder).readString(((Utf8) oldString374)); + } else { + charSequence374 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(374, charSequence374); + } else { + throw new RuntimeException(("Illegal union index for 'F374': "+ unionIndex374)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex375 = (decoder.readIndex()); + if (unionIndex375 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(375, null); + } else { + if (unionIndex375 == 1) { + Utf8 charSequence375; + Object oldString375 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(375); + if (oldString375 instanceof Utf8) { + charSequence375 = (decoder).readString(((Utf8) oldString375)); + } else { + charSequence375 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(375, charSequence375); + } else { + throw new RuntimeException(("Illegal union index for 'F375': "+ unionIndex375)); + } + } + int unionIndex376 = (decoder.readIndex()); + if (unionIndex376 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(376, null); + } else { + if (unionIndex376 == 1) { + Utf8 charSequence376; + Object oldString376 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(376); + if (oldString376 instanceof Utf8) { + charSequence376 = (decoder).readString(((Utf8) oldString376)); + } else { + charSequence376 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(376, charSequence376); + } else { + throw new RuntimeException(("Illegal union index for 'F376': "+ unionIndex376)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex377 = (decoder.readIndex()); + if (unionIndex377 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(377, null); + } else { + if (unionIndex377 == 1) { + Utf8 charSequence377; + Object oldString377 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(377); + if (oldString377 instanceof Utf8) { + charSequence377 = (decoder).readString(((Utf8) oldString377)); + } else { + charSequence377 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(377, charSequence377); + } else { + throw new RuntimeException(("Illegal union index for 'F377': "+ unionIndex377)); + } + } + int unionIndex378 = (decoder.readIndex()); + if (unionIndex378 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(378, null); + } else { + if (unionIndex378 == 1) { + Utf8 charSequence378; + Object oldString378 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(378); + if (oldString378 instanceof Utf8) { + charSequence378 = (decoder).readString(((Utf8) oldString378)); + } else { + charSequence378 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(378, charSequence378); + } else { + throw new RuntimeException(("Illegal union index for 'F378': "+ unionIndex378)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex379 = (decoder.readIndex()); + if (unionIndex379 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(379, null); + } else { + if (unionIndex379 == 1) { + Utf8 charSequence379; + Object oldString379 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(379); + if (oldString379 instanceof Utf8) { + charSequence379 = (decoder).readString(((Utf8) oldString379)); + } else { + charSequence379 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(379, charSequence379); + } else { + throw new RuntimeException(("Illegal union index for 'F379': "+ unionIndex379)); + } + } + int unionIndex380 = (decoder.readIndex()); + if (unionIndex380 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(380, null); + } else { + if (unionIndex380 == 1) { + Utf8 charSequence380; + Object oldString380 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(380); + if (oldString380 instanceof Utf8) { + charSequence380 = (decoder).readString(((Utf8) oldString380)); + } else { + charSequence380 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(380, charSequence380); + } else { + throw new RuntimeException(("Illegal union index for 'F380': "+ unionIndex380)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex381 = (decoder.readIndex()); + if (unionIndex381 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(381, null); + } else { + if (unionIndex381 == 1) { + Utf8 charSequence381; + Object oldString381 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(381); + if (oldString381 instanceof Utf8) { + charSequence381 = (decoder).readString(((Utf8) oldString381)); + } else { + charSequence381 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(381, charSequence381); + } else { + throw new RuntimeException(("Illegal union index for 'F381': "+ unionIndex381)); + } + } + int unionIndex382 = (decoder.readIndex()); + if (unionIndex382 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(382, null); + } else { + if (unionIndex382 == 1) { + Utf8 charSequence382; + Object oldString382 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(382); + if (oldString382 instanceof Utf8) { + charSequence382 = (decoder).readString(((Utf8) oldString382)); + } else { + charSequence382 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(382, charSequence382); + } else { + throw new RuntimeException(("Illegal union index for 'F382': "+ unionIndex382)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex383 = (decoder.readIndex()); + if (unionIndex383 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(383, null); + } else { + if (unionIndex383 == 1) { + Utf8 charSequence383; + Object oldString383 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(383); + if (oldString383 instanceof Utf8) { + charSequence383 = (decoder).readString(((Utf8) oldString383)); + } else { + charSequence383 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(383, charSequence383); + } else { + throw new RuntimeException(("Illegal union index for 'F383': "+ unionIndex383)); + } + } + int unionIndex384 = (decoder.readIndex()); + if (unionIndex384 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(384, null); + } else { + if (unionIndex384 == 1) { + Utf8 charSequence384; + Object oldString384 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(384); + if (oldString384 instanceof Utf8) { + charSequence384 = (decoder).readString(((Utf8) oldString384)); + } else { + charSequence384 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(384, charSequence384); + } else { + throw new RuntimeException(("Illegal union index for 'F384': "+ unionIndex384)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex385 = (decoder.readIndex()); + if (unionIndex385 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(385, null); + } else { + if (unionIndex385 == 1) { + Utf8 charSequence385; + Object oldString385 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(385); + if (oldString385 instanceof Utf8) { + charSequence385 = (decoder).readString(((Utf8) oldString385)); + } else { + charSequence385 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(385, charSequence385); + } else { + throw new RuntimeException(("Illegal union index for 'F385': "+ unionIndex385)); + } + } + int unionIndex386 = (decoder.readIndex()); + if (unionIndex386 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(386, null); + } else { + if (unionIndex386 == 1) { + Utf8 charSequence386; + Object oldString386 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(386); + if (oldString386 instanceof Utf8) { + charSequence386 = (decoder).readString(((Utf8) oldString386)); + } else { + charSequence386 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(386, charSequence386); + } else { + throw new RuntimeException(("Illegal union index for 'F386': "+ unionIndex386)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex387 = (decoder.readIndex()); + if (unionIndex387 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(387, null); + } else { + if (unionIndex387 == 1) { + Utf8 charSequence387; + Object oldString387 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(387); + if (oldString387 instanceof Utf8) { + charSequence387 = (decoder).readString(((Utf8) oldString387)); + } else { + charSequence387 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(387, charSequence387); + } else { + throw new RuntimeException(("Illegal union index for 'F387': "+ unionIndex387)); + } + } + int unionIndex388 = (decoder.readIndex()); + if (unionIndex388 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(388, null); + } else { + if (unionIndex388 == 1) { + Utf8 charSequence388; + Object oldString388 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(388); + if (oldString388 instanceof Utf8) { + charSequence388 = (decoder).readString(((Utf8) oldString388)); + } else { + charSequence388 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(388, charSequence388); + } else { + throw new RuntimeException(("Illegal union index for 'F388': "+ unionIndex388)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex389 = (decoder.readIndex()); + if (unionIndex389 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(389, null); + } else { + if (unionIndex389 == 1) { + Utf8 charSequence389; + Object oldString389 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(389); + if (oldString389 instanceof Utf8) { + charSequence389 = (decoder).readString(((Utf8) oldString389)); + } else { + charSequence389 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(389, charSequence389); + } else { + throw new RuntimeException(("Illegal union index for 'F389': "+ unionIndex389)); + } + } + int unionIndex390 = (decoder.readIndex()); + if (unionIndex390 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(390, null); + } else { + if (unionIndex390 == 1) { + Utf8 charSequence390; + Object oldString390 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(390); + if (oldString390 instanceof Utf8) { + charSequence390 = (decoder).readString(((Utf8) oldString390)); + } else { + charSequence390 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(390, charSequence390); + } else { + throw new RuntimeException(("Illegal union index for 'F390': "+ unionIndex390)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex391 = (decoder.readIndex()); + if (unionIndex391 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(391, null); + } else { + if (unionIndex391 == 1) { + Utf8 charSequence391; + Object oldString391 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(391); + if (oldString391 instanceof Utf8) { + charSequence391 = (decoder).readString(((Utf8) oldString391)); + } else { + charSequence391 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(391, charSequence391); + } else { + throw new RuntimeException(("Illegal union index for 'F391': "+ unionIndex391)); + } + } + int unionIndex392 = (decoder.readIndex()); + if (unionIndex392 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(392, null); + } else { + if (unionIndex392 == 1) { + Utf8 charSequence392; + Object oldString392 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(392); + if (oldString392 instanceof Utf8) { + charSequence392 = (decoder).readString(((Utf8) oldString392)); + } else { + charSequence392 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(392, charSequence392); + } else { + throw new RuntimeException(("Illegal union index for 'F392': "+ unionIndex392)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex393 = (decoder.readIndex()); + if (unionIndex393 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(393, null); + } else { + if (unionIndex393 == 1) { + Utf8 charSequence393; + Object oldString393 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(393); + if (oldString393 instanceof Utf8) { + charSequence393 = (decoder).readString(((Utf8) oldString393)); + } else { + charSequence393 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(393, charSequence393); + } else { + throw new RuntimeException(("Illegal union index for 'F393': "+ unionIndex393)); + } + } + int unionIndex394 = (decoder.readIndex()); + if (unionIndex394 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(394, null); + } else { + if (unionIndex394 == 1) { + Utf8 charSequence394; + Object oldString394 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(394); + if (oldString394 instanceof Utf8) { + charSequence394 = (decoder).readString(((Utf8) oldString394)); + } else { + charSequence394 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(394, charSequence394); + } else { + throw new RuntimeException(("Illegal union index for 'F394': "+ unionIndex394)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex395 = (decoder.readIndex()); + if (unionIndex395 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(395, null); + } else { + if (unionIndex395 == 1) { + Utf8 charSequence395; + Object oldString395 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(395); + if (oldString395 instanceof Utf8) { + charSequence395 = (decoder).readString(((Utf8) oldString395)); + } else { + charSequence395 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(395, charSequence395); + } else { + throw new RuntimeException(("Illegal union index for 'F395': "+ unionIndex395)); + } + } + int unionIndex396 = (decoder.readIndex()); + if (unionIndex396 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(396, null); + } else { + if (unionIndex396 == 1) { + Utf8 charSequence396; + Object oldString396 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(396); + if (oldString396 instanceof Utf8) { + charSequence396 = (decoder).readString(((Utf8) oldString396)); + } else { + charSequence396 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(396, charSequence396); + } else { + throw new RuntimeException(("Illegal union index for 'F396': "+ unionIndex396)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex397 = (decoder.readIndex()); + if (unionIndex397 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(397, null); + } else { + if (unionIndex397 == 1) { + Utf8 charSequence397; + Object oldString397 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(397); + if (oldString397 instanceof Utf8) { + charSequence397 = (decoder).readString(((Utf8) oldString397)); + } else { + charSequence397 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(397, charSequence397); + } else { + throw new RuntimeException(("Illegal union index for 'F397': "+ unionIndex397)); + } + } + int unionIndex398 = (decoder.readIndex()); + if (unionIndex398 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(398, null); + } else { + if (unionIndex398 == 1) { + Utf8 charSequence398; + Object oldString398 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(398); + if (oldString398 instanceof Utf8) { + charSequence398 = (decoder).readString(((Utf8) oldString398)); + } else { + charSequence398 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(398, charSequence398); + } else { + throw new RuntimeException(("Illegal union index for 'F398': "+ unionIndex398)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex399 = (decoder.readIndex()); + if (unionIndex399 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(399, null); + } else { + if (unionIndex399 == 1) { + Utf8 charSequence399; + Object oldString399 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(399); + if (oldString399 instanceof Utf8) { + charSequence399 = (decoder).readString(((Utf8) oldString399)); + } else { + charSequence399 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(399, charSequence399); + } else { + throw new RuntimeException(("Illegal union index for 'F399': "+ unionIndex399)); + } + } + int unionIndex400 = (decoder.readIndex()); + if (unionIndex400 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(400, null); + } else { + if (unionIndex400 == 1) { + Utf8 charSequence400; + Object oldString400 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(400); + if (oldString400 instanceof Utf8) { + charSequence400 = (decoder).readString(((Utf8) oldString400)); + } else { + charSequence400 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(400, charSequence400); + } else { + throw new RuntimeException(("Illegal union index for 'F400': "+ unionIndex400)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex401 = (decoder.readIndex()); + if (unionIndex401 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(401, null); + } else { + if (unionIndex401 == 1) { + Utf8 charSequence401; + Object oldString401 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(401); + if (oldString401 instanceof Utf8) { + charSequence401 = (decoder).readString(((Utf8) oldString401)); + } else { + charSequence401 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(401, charSequence401); + } else { + throw new RuntimeException(("Illegal union index for 'F401': "+ unionIndex401)); + } + } + int unionIndex402 = (decoder.readIndex()); + if (unionIndex402 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(402, null); + } else { + if (unionIndex402 == 1) { + Utf8 charSequence402; + Object oldString402 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(402); + if (oldString402 instanceof Utf8) { + charSequence402 = (decoder).readString(((Utf8) oldString402)); + } else { + charSequence402 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(402, charSequence402); + } else { + throw new RuntimeException(("Illegal union index for 'F402': "+ unionIndex402)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex403 = (decoder.readIndex()); + if (unionIndex403 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(403, null); + } else { + if (unionIndex403 == 1) { + Utf8 charSequence403; + Object oldString403 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(403); + if (oldString403 instanceof Utf8) { + charSequence403 = (decoder).readString(((Utf8) oldString403)); + } else { + charSequence403 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(403, charSequence403); + } else { + throw new RuntimeException(("Illegal union index for 'F403': "+ unionIndex403)); + } + } + int unionIndex404 = (decoder.readIndex()); + if (unionIndex404 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(404, null); + } else { + if (unionIndex404 == 1) { + Utf8 charSequence404; + Object oldString404 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(404); + if (oldString404 instanceof Utf8) { + charSequence404 = (decoder).readString(((Utf8) oldString404)); + } else { + charSequence404 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(404, charSequence404); + } else { + throw new RuntimeException(("Illegal union index for 'F404': "+ unionIndex404)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex405 = (decoder.readIndex()); + if (unionIndex405 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(405, null); + } else { + if (unionIndex405 == 1) { + Utf8 charSequence405; + Object oldString405 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(405); + if (oldString405 instanceof Utf8) { + charSequence405 = (decoder).readString(((Utf8) oldString405)); + } else { + charSequence405 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(405, charSequence405); + } else { + throw new RuntimeException(("Illegal union index for 'F405': "+ unionIndex405)); + } + } + int unionIndex406 = (decoder.readIndex()); + if (unionIndex406 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(406, null); + } else { + if (unionIndex406 == 1) { + Utf8 charSequence406; + Object oldString406 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(406); + if (oldString406 instanceof Utf8) { + charSequence406 = (decoder).readString(((Utf8) oldString406)); + } else { + charSequence406 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(406, charSequence406); + } else { + throw new RuntimeException(("Illegal union index for 'F406': "+ unionIndex406)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex407 = (decoder.readIndex()); + if (unionIndex407 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(407, null); + } else { + if (unionIndex407 == 1) { + Utf8 charSequence407; + Object oldString407 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(407); + if (oldString407 instanceof Utf8) { + charSequence407 = (decoder).readString(((Utf8) oldString407)); + } else { + charSequence407 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(407, charSequence407); + } else { + throw new RuntimeException(("Illegal union index for 'F407': "+ unionIndex407)); + } + } + int unionIndex408 = (decoder.readIndex()); + if (unionIndex408 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(408, null); + } else { + if (unionIndex408 == 1) { + Utf8 charSequence408; + Object oldString408 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(408); + if (oldString408 instanceof Utf8) { + charSequence408 = (decoder).readString(((Utf8) oldString408)); + } else { + charSequence408 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(408, charSequence408); + } else { + throw new RuntimeException(("Illegal union index for 'F408': "+ unionIndex408)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex409 = (decoder.readIndex()); + if (unionIndex409 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(409, null); + } else { + if (unionIndex409 == 1) { + Utf8 charSequence409; + Object oldString409 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(409); + if (oldString409 instanceof Utf8) { + charSequence409 = (decoder).readString(((Utf8) oldString409)); + } else { + charSequence409 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(409, charSequence409); + } else { + throw new RuntimeException(("Illegal union index for 'F409': "+ unionIndex409)); + } + } + int unionIndex410 = (decoder.readIndex()); + if (unionIndex410 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(410, null); + } else { + if (unionIndex410 == 1) { + Utf8 charSequence410; + Object oldString410 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(410); + if (oldString410 instanceof Utf8) { + charSequence410 = (decoder).readString(((Utf8) oldString410)); + } else { + charSequence410 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(410, charSequence410); + } else { + throw new RuntimeException(("Illegal union index for 'F410': "+ unionIndex410)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex411 = (decoder.readIndex()); + if (unionIndex411 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(411, null); + } else { + if (unionIndex411 == 1) { + Utf8 charSequence411; + Object oldString411 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(411); + if (oldString411 instanceof Utf8) { + charSequence411 = (decoder).readString(((Utf8) oldString411)); + } else { + charSequence411 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(411, charSequence411); + } else { + throw new RuntimeException(("Illegal union index for 'F411': "+ unionIndex411)); + } + } + int unionIndex412 = (decoder.readIndex()); + if (unionIndex412 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(412, null); + } else { + if (unionIndex412 == 1) { + Utf8 charSequence412; + Object oldString412 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(412); + if (oldString412 instanceof Utf8) { + charSequence412 = (decoder).readString(((Utf8) oldString412)); + } else { + charSequence412 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(412, charSequence412); + } else { + throw new RuntimeException(("Illegal union index for 'F412': "+ unionIndex412)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex413 = (decoder.readIndex()); + if (unionIndex413 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(413, null); + } else { + if (unionIndex413 == 1) { + Utf8 charSequence413; + Object oldString413 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(413); + if (oldString413 instanceof Utf8) { + charSequence413 = (decoder).readString(((Utf8) oldString413)); + } else { + charSequence413 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(413, charSequence413); + } else { + throw new RuntimeException(("Illegal union index for 'F413': "+ unionIndex413)); + } + } + int unionIndex414 = (decoder.readIndex()); + if (unionIndex414 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(414, null); + } else { + if (unionIndex414 == 1) { + Utf8 charSequence414; + Object oldString414 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(414); + if (oldString414 instanceof Utf8) { + charSequence414 = (decoder).readString(((Utf8) oldString414)); + } else { + charSequence414 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(414, charSequence414); + } else { + throw new RuntimeException(("Illegal union index for 'F414': "+ unionIndex414)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex415 = (decoder.readIndex()); + if (unionIndex415 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(415, null); + } else { + if (unionIndex415 == 1) { + Utf8 charSequence415; + Object oldString415 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(415); + if (oldString415 instanceof Utf8) { + charSequence415 = (decoder).readString(((Utf8) oldString415)); + } else { + charSequence415 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(415, charSequence415); + } else { + throw new RuntimeException(("Illegal union index for 'F415': "+ unionIndex415)); + } + } + int unionIndex416 = (decoder.readIndex()); + if (unionIndex416 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(416, null); + } else { + if (unionIndex416 == 1) { + Utf8 charSequence416; + Object oldString416 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(416); + if (oldString416 instanceof Utf8) { + charSequence416 = (decoder).readString(((Utf8) oldString416)); + } else { + charSequence416 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(416, charSequence416); + } else { + throw new RuntimeException(("Illegal union index for 'F416': "+ unionIndex416)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex417 = (decoder.readIndex()); + if (unionIndex417 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(417, null); + } else { + if (unionIndex417 == 1) { + Utf8 charSequence417; + Object oldString417 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(417); + if (oldString417 instanceof Utf8) { + charSequence417 = (decoder).readString(((Utf8) oldString417)); + } else { + charSequence417 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(417, charSequence417); + } else { + throw new RuntimeException(("Illegal union index for 'F417': "+ unionIndex417)); + } + } + int unionIndex418 = (decoder.readIndex()); + if (unionIndex418 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(418, null); + } else { + if (unionIndex418 == 1) { + Utf8 charSequence418; + Object oldString418 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(418); + if (oldString418 instanceof Utf8) { + charSequence418 = (decoder).readString(((Utf8) oldString418)); + } else { + charSequence418 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(418, charSequence418); + } else { + throw new RuntimeException(("Illegal union index for 'F418': "+ unionIndex418)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex419 = (decoder.readIndex()); + if (unionIndex419 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(419, null); + } else { + if (unionIndex419 == 1) { + Utf8 charSequence419; + Object oldString419 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(419); + if (oldString419 instanceof Utf8) { + charSequence419 = (decoder).readString(((Utf8) oldString419)); + } else { + charSequence419 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(419, charSequence419); + } else { + throw new RuntimeException(("Illegal union index for 'F419': "+ unionIndex419)); + } + } + int unionIndex420 = (decoder.readIndex()); + if (unionIndex420 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(420, null); + } else { + if (unionIndex420 == 1) { + Utf8 charSequence420; + Object oldString420 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(420); + if (oldString420 instanceof Utf8) { + charSequence420 = (decoder).readString(((Utf8) oldString420)); + } else { + charSequence420 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(420, charSequence420); + } else { + throw new RuntimeException(("Illegal union index for 'F420': "+ unionIndex420)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex421 = (decoder.readIndex()); + if (unionIndex421 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(421, null); + } else { + if (unionIndex421 == 1) { + Utf8 charSequence421; + Object oldString421 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(421); + if (oldString421 instanceof Utf8) { + charSequence421 = (decoder).readString(((Utf8) oldString421)); + } else { + charSequence421 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(421, charSequence421); + } else { + throw new RuntimeException(("Illegal union index for 'F421': "+ unionIndex421)); + } + } + int unionIndex422 = (decoder.readIndex()); + if (unionIndex422 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(422, null); + } else { + if (unionIndex422 == 1) { + Utf8 charSequence422; + Object oldString422 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(422); + if (oldString422 instanceof Utf8) { + charSequence422 = (decoder).readString(((Utf8) oldString422)); + } else { + charSequence422 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(422, charSequence422); + } else { + throw new RuntimeException(("Illegal union index for 'F422': "+ unionIndex422)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex423 = (decoder.readIndex()); + if (unionIndex423 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(423, null); + } else { + if (unionIndex423 == 1) { + Utf8 charSequence423; + Object oldString423 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(423); + if (oldString423 instanceof Utf8) { + charSequence423 = (decoder).readString(((Utf8) oldString423)); + } else { + charSequence423 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(423, charSequence423); + } else { + throw new RuntimeException(("Illegal union index for 'F423': "+ unionIndex423)); + } + } + int unionIndex424 = (decoder.readIndex()); + if (unionIndex424 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(424, null); + } else { + if (unionIndex424 == 1) { + Utf8 charSequence424; + Object oldString424 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(424); + if (oldString424 instanceof Utf8) { + charSequence424 = (decoder).readString(((Utf8) oldString424)); + } else { + charSequence424 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(424, charSequence424); + } else { + throw new RuntimeException(("Illegal union index for 'F424': "+ unionIndex424)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex425 = (decoder.readIndex()); + if (unionIndex425 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(425, null); + } else { + if (unionIndex425 == 1) { + Utf8 charSequence425; + Object oldString425 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(425); + if (oldString425 instanceof Utf8) { + charSequence425 = (decoder).readString(((Utf8) oldString425)); + } else { + charSequence425 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(425, charSequence425); + } else { + throw new RuntimeException(("Illegal union index for 'F425': "+ unionIndex425)); + } + } + int unionIndex426 = (decoder.readIndex()); + if (unionIndex426 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(426, null); + } else { + if (unionIndex426 == 1) { + Utf8 charSequence426; + Object oldString426 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(426); + if (oldString426 instanceof Utf8) { + charSequence426 = (decoder).readString(((Utf8) oldString426)); + } else { + charSequence426 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(426, charSequence426); + } else { + throw new RuntimeException(("Illegal union index for 'F426': "+ unionIndex426)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex427 = (decoder.readIndex()); + if (unionIndex427 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(427, null); + } else { + if (unionIndex427 == 1) { + Utf8 charSequence427; + Object oldString427 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(427); + if (oldString427 instanceof Utf8) { + charSequence427 = (decoder).readString(((Utf8) oldString427)); + } else { + charSequence427 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(427, charSequence427); + } else { + throw new RuntimeException(("Illegal union index for 'F427': "+ unionIndex427)); + } + } + int unionIndex428 = (decoder.readIndex()); + if (unionIndex428 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(428, null); + } else { + if (unionIndex428 == 1) { + Utf8 charSequence428; + Object oldString428 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(428); + if (oldString428 instanceof Utf8) { + charSequence428 = (decoder).readString(((Utf8) oldString428)); + } else { + charSequence428 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(428, charSequence428); + } else { + throw new RuntimeException(("Illegal union index for 'F428': "+ unionIndex428)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex429 = (decoder.readIndex()); + if (unionIndex429 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(429, null); + } else { + if (unionIndex429 == 1) { + Utf8 charSequence429; + Object oldString429 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(429); + if (oldString429 instanceof Utf8) { + charSequence429 = (decoder).readString(((Utf8) oldString429)); + } else { + charSequence429 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(429, charSequence429); + } else { + throw new RuntimeException(("Illegal union index for 'F429': "+ unionIndex429)); + } + } + int unionIndex430 = (decoder.readIndex()); + if (unionIndex430 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(430, null); + } else { + if (unionIndex430 == 1) { + Utf8 charSequence430; + Object oldString430 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(430); + if (oldString430 instanceof Utf8) { + charSequence430 = (decoder).readString(((Utf8) oldString430)); + } else { + charSequence430 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(430, charSequence430); + } else { + throw new RuntimeException(("Illegal union index for 'F430': "+ unionIndex430)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex431 = (decoder.readIndex()); + if (unionIndex431 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(431, null); + } else { + if (unionIndex431 == 1) { + Utf8 charSequence431; + Object oldString431 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(431); + if (oldString431 instanceof Utf8) { + charSequence431 = (decoder).readString(((Utf8) oldString431)); + } else { + charSequence431 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(431, charSequence431); + } else { + throw new RuntimeException(("Illegal union index for 'F431': "+ unionIndex431)); + } + } + int unionIndex432 = (decoder.readIndex()); + if (unionIndex432 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(432, null); + } else { + if (unionIndex432 == 1) { + Utf8 charSequence432; + Object oldString432 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(432); + if (oldString432 instanceof Utf8) { + charSequence432 = (decoder).readString(((Utf8) oldString432)); + } else { + charSequence432 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(432, charSequence432); + } else { + throw new RuntimeException(("Illegal union index for 'F432': "+ unionIndex432)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex433 = (decoder.readIndex()); + if (unionIndex433 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(433, null); + } else { + if (unionIndex433 == 1) { + Utf8 charSequence433; + Object oldString433 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(433); + if (oldString433 instanceof Utf8) { + charSequence433 = (decoder).readString(((Utf8) oldString433)); + } else { + charSequence433 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(433, charSequence433); + } else { + throw new RuntimeException(("Illegal union index for 'F433': "+ unionIndex433)); + } + } + int unionIndex434 = (decoder.readIndex()); + if (unionIndex434 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(434, null); + } else { + if (unionIndex434 == 1) { + Utf8 charSequence434; + Object oldString434 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(434); + if (oldString434 instanceof Utf8) { + charSequence434 = (decoder).readString(((Utf8) oldString434)); + } else { + charSequence434 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(434, charSequence434); + } else { + throw new RuntimeException(("Illegal union index for 'F434': "+ unionIndex434)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex435 = (decoder.readIndex()); + if (unionIndex435 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(435, null); + } else { + if (unionIndex435 == 1) { + Utf8 charSequence435; + Object oldString435 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(435); + if (oldString435 instanceof Utf8) { + charSequence435 = (decoder).readString(((Utf8) oldString435)); + } else { + charSequence435 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(435, charSequence435); + } else { + throw new RuntimeException(("Illegal union index for 'F435': "+ unionIndex435)); + } + } + int unionIndex436 = (decoder.readIndex()); + if (unionIndex436 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(436, null); + } else { + if (unionIndex436 == 1) { + Utf8 charSequence436; + Object oldString436 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(436); + if (oldString436 instanceof Utf8) { + charSequence436 = (decoder).readString(((Utf8) oldString436)); + } else { + charSequence436 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(436, charSequence436); + } else { + throw new RuntimeException(("Illegal union index for 'F436': "+ unionIndex436)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex437 = (decoder.readIndex()); + if (unionIndex437 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(437, null); + } else { + if (unionIndex437 == 1) { + Utf8 charSequence437; + Object oldString437 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(437); + if (oldString437 instanceof Utf8) { + charSequence437 = (decoder).readString(((Utf8) oldString437)); + } else { + charSequence437 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(437, charSequence437); + } else { + throw new RuntimeException(("Illegal union index for 'F437': "+ unionIndex437)); + } + } + int unionIndex438 = (decoder.readIndex()); + if (unionIndex438 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(438, null); + } else { + if (unionIndex438 == 1) { + Utf8 charSequence438; + Object oldString438 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(438); + if (oldString438 instanceof Utf8) { + charSequence438 = (decoder).readString(((Utf8) oldString438)); + } else { + charSequence438 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(438, charSequence438); + } else { + throw new RuntimeException(("Illegal union index for 'F438': "+ unionIndex438)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex439 = (decoder.readIndex()); + if (unionIndex439 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(439, null); + } else { + if (unionIndex439 == 1) { + Utf8 charSequence439; + Object oldString439 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(439); + if (oldString439 instanceof Utf8) { + charSequence439 = (decoder).readString(((Utf8) oldString439)); + } else { + charSequence439 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(439, charSequence439); + } else { + throw new RuntimeException(("Illegal union index for 'F439': "+ unionIndex439)); + } + } + int unionIndex440 = (decoder.readIndex()); + if (unionIndex440 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(440, null); + } else { + if (unionIndex440 == 1) { + Utf8 charSequence440; + Object oldString440 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(440); + if (oldString440 instanceof Utf8) { + charSequence440 = (decoder).readString(((Utf8) oldString440)); + } else { + charSequence440 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(440, charSequence440); + } else { + throw new RuntimeException(("Illegal union index for 'F440': "+ unionIndex440)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex441 = (decoder.readIndex()); + if (unionIndex441 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(441, null); + } else { + if (unionIndex441 == 1) { + Utf8 charSequence441; + Object oldString441 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(441); + if (oldString441 instanceof Utf8) { + charSequence441 = (decoder).readString(((Utf8) oldString441)); + } else { + charSequence441 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(441, charSequence441); + } else { + throw new RuntimeException(("Illegal union index for 'F441': "+ unionIndex441)); + } + } + int unionIndex442 = (decoder.readIndex()); + if (unionIndex442 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(442, null); + } else { + if (unionIndex442 == 1) { + Utf8 charSequence442; + Object oldString442 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(442); + if (oldString442 instanceof Utf8) { + charSequence442 = (decoder).readString(((Utf8) oldString442)); + } else { + charSequence442 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(442, charSequence442); + } else { + throw new RuntimeException(("Illegal union index for 'F442': "+ unionIndex442)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex443 = (decoder.readIndex()); + if (unionIndex443 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(443, null); + } else { + if (unionIndex443 == 1) { + Utf8 charSequence443; + Object oldString443 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(443); + if (oldString443 instanceof Utf8) { + charSequence443 = (decoder).readString(((Utf8) oldString443)); + } else { + charSequence443 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(443, charSequence443); + } else { + throw new RuntimeException(("Illegal union index for 'F443': "+ unionIndex443)); + } + } + int unionIndex444 = (decoder.readIndex()); + if (unionIndex444 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(444, null); + } else { + if (unionIndex444 == 1) { + Utf8 charSequence444; + Object oldString444 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(444); + if (oldString444 instanceof Utf8) { + charSequence444 = (decoder).readString(((Utf8) oldString444)); + } else { + charSequence444 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(444, charSequence444); + } else { + throw new RuntimeException(("Illegal union index for 'F444': "+ unionIndex444)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex445 = (decoder.readIndex()); + if (unionIndex445 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(445, null); + } else { + if (unionIndex445 == 1) { + Utf8 charSequence445; + Object oldString445 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(445); + if (oldString445 instanceof Utf8) { + charSequence445 = (decoder).readString(((Utf8) oldString445)); + } else { + charSequence445 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(445, charSequence445); + } else { + throw new RuntimeException(("Illegal union index for 'F445': "+ unionIndex445)); + } + } + int unionIndex446 = (decoder.readIndex()); + if (unionIndex446 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(446, null); + } else { + if (unionIndex446 == 1) { + Utf8 charSequence446; + Object oldString446 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(446); + if (oldString446 instanceof Utf8) { + charSequence446 = (decoder).readString(((Utf8) oldString446)); + } else { + charSequence446 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(446, charSequence446); + } else { + throw new RuntimeException(("Illegal union index for 'F446': "+ unionIndex446)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex447 = (decoder.readIndex()); + if (unionIndex447 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(447, null); + } else { + if (unionIndex447 == 1) { + Utf8 charSequence447; + Object oldString447 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(447); + if (oldString447 instanceof Utf8) { + charSequence447 = (decoder).readString(((Utf8) oldString447)); + } else { + charSequence447 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(447, charSequence447); + } else { + throw new RuntimeException(("Illegal union index for 'F447': "+ unionIndex447)); + } + } + int unionIndex448 = (decoder.readIndex()); + if (unionIndex448 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(448, null); + } else { + if (unionIndex448 == 1) { + Utf8 charSequence448; + Object oldString448 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(448); + if (oldString448 instanceof Utf8) { + charSequence448 = (decoder).readString(((Utf8) oldString448)); + } else { + charSequence448 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(448, charSequence448); + } else { + throw new RuntimeException(("Illegal union index for 'F448': "+ unionIndex448)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex449 = (decoder.readIndex()); + if (unionIndex449 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(449, null); + } else { + if (unionIndex449 == 1) { + Utf8 charSequence449; + Object oldString449 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(449); + if (oldString449 instanceof Utf8) { + charSequence449 = (decoder).readString(((Utf8) oldString449)); + } else { + charSequence449 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(449, charSequence449); + } else { + throw new RuntimeException(("Illegal union index for 'F449': "+ unionIndex449)); + } + } + int unionIndex450 = (decoder.readIndex()); + if (unionIndex450 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(450, null); + } else { + if (unionIndex450 == 1) { + Utf8 charSequence450; + Object oldString450 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(450); + if (oldString450 instanceof Utf8) { + charSequence450 = (decoder).readString(((Utf8) oldString450)); + } else { + charSequence450 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(450, charSequence450); + } else { + throw new RuntimeException(("Illegal union index for 'F450': "+ unionIndex450)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex451 = (decoder.readIndex()); + if (unionIndex451 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(451, null); + } else { + if (unionIndex451 == 1) { + Utf8 charSequence451; + Object oldString451 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(451); + if (oldString451 instanceof Utf8) { + charSequence451 = (decoder).readString(((Utf8) oldString451)); + } else { + charSequence451 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(451, charSequence451); + } else { + throw new RuntimeException(("Illegal union index for 'F451': "+ unionIndex451)); + } + } + int unionIndex452 = (decoder.readIndex()); + if (unionIndex452 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(452, null); + } else { + if (unionIndex452 == 1) { + Utf8 charSequence452; + Object oldString452 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(452); + if (oldString452 instanceof Utf8) { + charSequence452 = (decoder).readString(((Utf8) oldString452)); + } else { + charSequence452 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(452, charSequence452); + } else { + throw new RuntimeException(("Illegal union index for 'F452': "+ unionIndex452)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex453 = (decoder.readIndex()); + if (unionIndex453 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(453, null); + } else { + if (unionIndex453 == 1) { + Utf8 charSequence453; + Object oldString453 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(453); + if (oldString453 instanceof Utf8) { + charSequence453 = (decoder).readString(((Utf8) oldString453)); + } else { + charSequence453 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(453, charSequence453); + } else { + throw new RuntimeException(("Illegal union index for 'F453': "+ unionIndex453)); + } + } + int unionIndex454 = (decoder.readIndex()); + if (unionIndex454 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(454, null); + } else { + if (unionIndex454 == 1) { + Utf8 charSequence454; + Object oldString454 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(454); + if (oldString454 instanceof Utf8) { + charSequence454 = (decoder).readString(((Utf8) oldString454)); + } else { + charSequence454 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(454, charSequence454); + } else { + throw new RuntimeException(("Illegal union index for 'F454': "+ unionIndex454)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex455 = (decoder.readIndex()); + if (unionIndex455 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(455, null); + } else { + if (unionIndex455 == 1) { + Utf8 charSequence455; + Object oldString455 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(455); + if (oldString455 instanceof Utf8) { + charSequence455 = (decoder).readString(((Utf8) oldString455)); + } else { + charSequence455 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(455, charSequence455); + } else { + throw new RuntimeException(("Illegal union index for 'F455': "+ unionIndex455)); + } + } + int unionIndex456 = (decoder.readIndex()); + if (unionIndex456 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(456, null); + } else { + if (unionIndex456 == 1) { + Utf8 charSequence456; + Object oldString456 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(456); + if (oldString456 instanceof Utf8) { + charSequence456 = (decoder).readString(((Utf8) oldString456)); + } else { + charSequence456 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(456, charSequence456); + } else { + throw new RuntimeException(("Illegal union index for 'F456': "+ unionIndex456)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex457 = (decoder.readIndex()); + if (unionIndex457 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(457, null); + } else { + if (unionIndex457 == 1) { + Utf8 charSequence457; + Object oldString457 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(457); + if (oldString457 instanceof Utf8) { + charSequence457 = (decoder).readString(((Utf8) oldString457)); + } else { + charSequence457 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(457, charSequence457); + } else { + throw new RuntimeException(("Illegal union index for 'F457': "+ unionIndex457)); + } + } + int unionIndex458 = (decoder.readIndex()); + if (unionIndex458 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(458, null); + } else { + if (unionIndex458 == 1) { + Utf8 charSequence458; + Object oldString458 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(458); + if (oldString458 instanceof Utf8) { + charSequence458 = (decoder).readString(((Utf8) oldString458)); + } else { + charSequence458 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(458, charSequence458); + } else { + throw new RuntimeException(("Illegal union index for 'F458': "+ unionIndex458)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex459 = (decoder.readIndex()); + if (unionIndex459 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(459, null); + } else { + if (unionIndex459 == 1) { + Utf8 charSequence459; + Object oldString459 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(459); + if (oldString459 instanceof Utf8) { + charSequence459 = (decoder).readString(((Utf8) oldString459)); + } else { + charSequence459 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(459, charSequence459); + } else { + throw new RuntimeException(("Illegal union index for 'F459': "+ unionIndex459)); + } + } + int unionIndex460 = (decoder.readIndex()); + if (unionIndex460 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(460, null); + } else { + if (unionIndex460 == 1) { + Utf8 charSequence460; + Object oldString460 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(460); + if (oldString460 instanceof Utf8) { + charSequence460 = (decoder).readString(((Utf8) oldString460)); + } else { + charSequence460 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(460, charSequence460); + } else { + throw new RuntimeException(("Illegal union index for 'F460': "+ unionIndex460)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex461 = (decoder.readIndex()); + if (unionIndex461 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(461, null); + } else { + if (unionIndex461 == 1) { + Utf8 charSequence461; + Object oldString461 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(461); + if (oldString461 instanceof Utf8) { + charSequence461 = (decoder).readString(((Utf8) oldString461)); + } else { + charSequence461 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(461, charSequence461); + } else { + throw new RuntimeException(("Illegal union index for 'F461': "+ unionIndex461)); + } + } + int unionIndex462 = (decoder.readIndex()); + if (unionIndex462 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(462, null); + } else { + if (unionIndex462 == 1) { + Utf8 charSequence462; + Object oldString462 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(462); + if (oldString462 instanceof Utf8) { + charSequence462 = (decoder).readString(((Utf8) oldString462)); + } else { + charSequence462 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(462, charSequence462); + } else { + throw new RuntimeException(("Illegal union index for 'F462': "+ unionIndex462)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex463 = (decoder.readIndex()); + if (unionIndex463 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(463, null); + } else { + if (unionIndex463 == 1) { + Utf8 charSequence463; + Object oldString463 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(463); + if (oldString463 instanceof Utf8) { + charSequence463 = (decoder).readString(((Utf8) oldString463)); + } else { + charSequence463 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(463, charSequence463); + } else { + throw new RuntimeException(("Illegal union index for 'F463': "+ unionIndex463)); + } + } + int unionIndex464 = (decoder.readIndex()); + if (unionIndex464 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(464, null); + } else { + if (unionIndex464 == 1) { + Utf8 charSequence464; + Object oldString464 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(464); + if (oldString464 instanceof Utf8) { + charSequence464 = (decoder).readString(((Utf8) oldString464)); + } else { + charSequence464 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(464, charSequence464); + } else { + throw new RuntimeException(("Illegal union index for 'F464': "+ unionIndex464)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex465 = (decoder.readIndex()); + if (unionIndex465 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(465, null); + } else { + if (unionIndex465 == 1) { + Utf8 charSequence465; + Object oldString465 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(465); + if (oldString465 instanceof Utf8) { + charSequence465 = (decoder).readString(((Utf8) oldString465)); + } else { + charSequence465 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(465, charSequence465); + } else { + throw new RuntimeException(("Illegal union index for 'F465': "+ unionIndex465)); + } + } + int unionIndex466 = (decoder.readIndex()); + if (unionIndex466 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(466, null); + } else { + if (unionIndex466 == 1) { + Utf8 charSequence466; + Object oldString466 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(466); + if (oldString466 instanceof Utf8) { + charSequence466 = (decoder).readString(((Utf8) oldString466)); + } else { + charSequence466 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(466, charSequence466); + } else { + throw new RuntimeException(("Illegal union index for 'F466': "+ unionIndex466)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex467 = (decoder.readIndex()); + if (unionIndex467 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(467, null); + } else { + if (unionIndex467 == 1) { + Utf8 charSequence467; + Object oldString467 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(467); + if (oldString467 instanceof Utf8) { + charSequence467 = (decoder).readString(((Utf8) oldString467)); + } else { + charSequence467 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(467, charSequence467); + } else { + throw new RuntimeException(("Illegal union index for 'F467': "+ unionIndex467)); + } + } + int unionIndex468 = (decoder.readIndex()); + if (unionIndex468 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(468, null); + } else { + if (unionIndex468 == 1) { + Utf8 charSequence468; + Object oldString468 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(468); + if (oldString468 instanceof Utf8) { + charSequence468 = (decoder).readString(((Utf8) oldString468)); + } else { + charSequence468 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(468, charSequence468); + } else { + throw new RuntimeException(("Illegal union index for 'F468': "+ unionIndex468)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex469 = (decoder.readIndex()); + if (unionIndex469 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(469, null); + } else { + if (unionIndex469 == 1) { + Utf8 charSequence469; + Object oldString469 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(469); + if (oldString469 instanceof Utf8) { + charSequence469 = (decoder).readString(((Utf8) oldString469)); + } else { + charSequence469 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(469, charSequence469); + } else { + throw new RuntimeException(("Illegal union index for 'F469': "+ unionIndex469)); + } + } + int unionIndex470 = (decoder.readIndex()); + if (unionIndex470 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(470, null); + } else { + if (unionIndex470 == 1) { + Utf8 charSequence470; + Object oldString470 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(470); + if (oldString470 instanceof Utf8) { + charSequence470 = (decoder).readString(((Utf8) oldString470)); + } else { + charSequence470 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(470, charSequence470); + } else { + throw new RuntimeException(("Illegal union index for 'F470': "+ unionIndex470)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex471 = (decoder.readIndex()); + if (unionIndex471 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(471, null); + } else { + if (unionIndex471 == 1) { + Utf8 charSequence471; + Object oldString471 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(471); + if (oldString471 instanceof Utf8) { + charSequence471 = (decoder).readString(((Utf8) oldString471)); + } else { + charSequence471 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(471, charSequence471); + } else { + throw new RuntimeException(("Illegal union index for 'F471': "+ unionIndex471)); + } + } + int unionIndex472 = (decoder.readIndex()); + if (unionIndex472 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(472, null); + } else { + if (unionIndex472 == 1) { + Utf8 charSequence472; + Object oldString472 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(472); + if (oldString472 instanceof Utf8) { + charSequence472 = (decoder).readString(((Utf8) oldString472)); + } else { + charSequence472 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(472, charSequence472); + } else { + throw new RuntimeException(("Illegal union index for 'F472': "+ unionIndex472)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex473 = (decoder.readIndex()); + if (unionIndex473 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(473, null); + } else { + if (unionIndex473 == 1) { + Utf8 charSequence473; + Object oldString473 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(473); + if (oldString473 instanceof Utf8) { + charSequence473 = (decoder).readString(((Utf8) oldString473)); + } else { + charSequence473 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(473, charSequence473); + } else { + throw new RuntimeException(("Illegal union index for 'F473': "+ unionIndex473)); + } + } + int unionIndex474 = (decoder.readIndex()); + if (unionIndex474 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(474, null); + } else { + if (unionIndex474 == 1) { + Utf8 charSequence474; + Object oldString474 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(474); + if (oldString474 instanceof Utf8) { + charSequence474 = (decoder).readString(((Utf8) oldString474)); + } else { + charSequence474 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(474, charSequence474); + } else { + throw new RuntimeException(("Illegal union index for 'F474': "+ unionIndex474)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex475 = (decoder.readIndex()); + if (unionIndex475 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(475, null); + } else { + if (unionIndex475 == 1) { + Utf8 charSequence475; + Object oldString475 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(475); + if (oldString475 instanceof Utf8) { + charSequence475 = (decoder).readString(((Utf8) oldString475)); + } else { + charSequence475 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(475, charSequence475); + } else { + throw new RuntimeException(("Illegal union index for 'F475': "+ unionIndex475)); + } + } + int unionIndex476 = (decoder.readIndex()); + if (unionIndex476 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(476, null); + } else { + if (unionIndex476 == 1) { + Utf8 charSequence476; + Object oldString476 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(476); + if (oldString476 instanceof Utf8) { + charSequence476 = (decoder).readString(((Utf8) oldString476)); + } else { + charSequence476 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(476, charSequence476); + } else { + throw new RuntimeException(("Illegal union index for 'F476': "+ unionIndex476)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex477 = (decoder.readIndex()); + if (unionIndex477 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(477, null); + } else { + if (unionIndex477 == 1) { + Utf8 charSequence477; + Object oldString477 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(477); + if (oldString477 instanceof Utf8) { + charSequence477 = (decoder).readString(((Utf8) oldString477)); + } else { + charSequence477 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(477, charSequence477); + } else { + throw new RuntimeException(("Illegal union index for 'F477': "+ unionIndex477)); + } + } + int unionIndex478 = (decoder.readIndex()); + if (unionIndex478 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(478, null); + } else { + if (unionIndex478 == 1) { + Utf8 charSequence478; + Object oldString478 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(478); + if (oldString478 instanceof Utf8) { + charSequence478 = (decoder).readString(((Utf8) oldString478)); + } else { + charSequence478 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(478, charSequence478); + } else { + throw new RuntimeException(("Illegal union index for 'F478': "+ unionIndex478)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex479 = (decoder.readIndex()); + if (unionIndex479 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(479, null); + } else { + if (unionIndex479 == 1) { + Utf8 charSequence479; + Object oldString479 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(479); + if (oldString479 instanceof Utf8) { + charSequence479 = (decoder).readString(((Utf8) oldString479)); + } else { + charSequence479 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(479, charSequence479); + } else { + throw new RuntimeException(("Illegal union index for 'F479': "+ unionIndex479)); + } + } + int unionIndex480 = (decoder.readIndex()); + if (unionIndex480 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(480, null); + } else { + if (unionIndex480 == 1) { + Utf8 charSequence480; + Object oldString480 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(480); + if (oldString480 instanceof Utf8) { + charSequence480 = (decoder).readString(((Utf8) oldString480)); + } else { + charSequence480 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(480, charSequence480); + } else { + throw new RuntimeException(("Illegal union index for 'F480': "+ unionIndex480)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex481 = (decoder.readIndex()); + if (unionIndex481 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(481, null); + } else { + if (unionIndex481 == 1) { + Utf8 charSequence481; + Object oldString481 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(481); + if (oldString481 instanceof Utf8) { + charSequence481 = (decoder).readString(((Utf8) oldString481)); + } else { + charSequence481 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(481, charSequence481); + } else { + throw new RuntimeException(("Illegal union index for 'F481': "+ unionIndex481)); + } + } + int unionIndex482 = (decoder.readIndex()); + if (unionIndex482 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(482, null); + } else { + if (unionIndex482 == 1) { + Utf8 charSequence482; + Object oldString482 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(482); + if (oldString482 instanceof Utf8) { + charSequence482 = (decoder).readString(((Utf8) oldString482)); + } else { + charSequence482 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(482, charSequence482); + } else { + throw new RuntimeException(("Illegal union index for 'F482': "+ unionIndex482)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex483 = (decoder.readIndex()); + if (unionIndex483 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(483, null); + } else { + if (unionIndex483 == 1) { + Utf8 charSequence483; + Object oldString483 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(483); + if (oldString483 instanceof Utf8) { + charSequence483 = (decoder).readString(((Utf8) oldString483)); + } else { + charSequence483 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(483, charSequence483); + } else { + throw new RuntimeException(("Illegal union index for 'F483': "+ unionIndex483)); + } + } + int unionIndex484 = (decoder.readIndex()); + if (unionIndex484 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(484, null); + } else { + if (unionIndex484 == 1) { + Utf8 charSequence484; + Object oldString484 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(484); + if (oldString484 instanceof Utf8) { + charSequence484 = (decoder).readString(((Utf8) oldString484)); + } else { + charSequence484 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(484, charSequence484); + } else { + throw new RuntimeException(("Illegal union index for 'F484': "+ unionIndex484)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex485 = (decoder.readIndex()); + if (unionIndex485 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(485, null); + } else { + if (unionIndex485 == 1) { + Utf8 charSequence485; + Object oldString485 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(485); + if (oldString485 instanceof Utf8) { + charSequence485 = (decoder).readString(((Utf8) oldString485)); + } else { + charSequence485 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(485, charSequence485); + } else { + throw new RuntimeException(("Illegal union index for 'F485': "+ unionIndex485)); + } + } + int unionIndex486 = (decoder.readIndex()); + if (unionIndex486 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(486, null); + } else { + if (unionIndex486 == 1) { + Utf8 charSequence486; + Object oldString486 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(486); + if (oldString486 instanceof Utf8) { + charSequence486 = (decoder).readString(((Utf8) oldString486)); + } else { + charSequence486 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(486, charSequence486); + } else { + throw new RuntimeException(("Illegal union index for 'F486': "+ unionIndex486)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex487 = (decoder.readIndex()); + if (unionIndex487 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(487, null); + } else { + if (unionIndex487 == 1) { + Utf8 charSequence487; + Object oldString487 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(487); + if (oldString487 instanceof Utf8) { + charSequence487 = (decoder).readString(((Utf8) oldString487)); + } else { + charSequence487 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(487, charSequence487); + } else { + throw new RuntimeException(("Illegal union index for 'F487': "+ unionIndex487)); + } + } + int unionIndex488 = (decoder.readIndex()); + if (unionIndex488 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(488, null); + } else { + if (unionIndex488 == 1) { + Utf8 charSequence488; + Object oldString488 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(488); + if (oldString488 instanceof Utf8) { + charSequence488 = (decoder).readString(((Utf8) oldString488)); + } else { + charSequence488 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(488, charSequence488); + } else { + throw new RuntimeException(("Illegal union index for 'F488': "+ unionIndex488)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex489 = (decoder.readIndex()); + if (unionIndex489 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(489, null); + } else { + if (unionIndex489 == 1) { + Utf8 charSequence489; + Object oldString489 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(489); + if (oldString489 instanceof Utf8) { + charSequence489 = (decoder).readString(((Utf8) oldString489)); + } else { + charSequence489 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(489, charSequence489); + } else { + throw new RuntimeException(("Illegal union index for 'F489': "+ unionIndex489)); + } + } + int unionIndex490 = (decoder.readIndex()); + if (unionIndex490 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(490, null); + } else { + if (unionIndex490 == 1) { + Utf8 charSequence490; + Object oldString490 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(490); + if (oldString490 instanceof Utf8) { + charSequence490 = (decoder).readString(((Utf8) oldString490)); + } else { + charSequence490 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(490, charSequence490); + } else { + throw new RuntimeException(("Illegal union index for 'F490': "+ unionIndex490)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex491 = (decoder.readIndex()); + if (unionIndex491 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(491, null); + } else { + if (unionIndex491 == 1) { + Utf8 charSequence491; + Object oldString491 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(491); + if (oldString491 instanceof Utf8) { + charSequence491 = (decoder).readString(((Utf8) oldString491)); + } else { + charSequence491 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(491, charSequence491); + } else { + throw new RuntimeException(("Illegal union index for 'F491': "+ unionIndex491)); + } + } + int unionIndex492 = (decoder.readIndex()); + if (unionIndex492 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(492, null); + } else { + if (unionIndex492 == 1) { + Utf8 charSequence492; + Object oldString492 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(492); + if (oldString492 instanceof Utf8) { + charSequence492 = (decoder).readString(((Utf8) oldString492)); + } else { + charSequence492 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(492, charSequence492); + } else { + throw new RuntimeException(("Illegal union index for 'F492': "+ unionIndex492)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex493 = (decoder.readIndex()); + if (unionIndex493 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(493, null); + } else { + if (unionIndex493 == 1) { + Utf8 charSequence493; + Object oldString493 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(493); + if (oldString493 instanceof Utf8) { + charSequence493 = (decoder).readString(((Utf8) oldString493)); + } else { + charSequence493 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(493, charSequence493); + } else { + throw new RuntimeException(("Illegal union index for 'F493': "+ unionIndex493)); + } + } + int unionIndex494 = (decoder.readIndex()); + if (unionIndex494 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(494, null); + } else { + if (unionIndex494 == 1) { + Utf8 charSequence494; + Object oldString494 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(494); + if (oldString494 instanceof Utf8) { + charSequence494 = (decoder).readString(((Utf8) oldString494)); + } else { + charSequence494 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(494, charSequence494); + } else { + throw new RuntimeException(("Illegal union index for 'F494': "+ unionIndex494)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex495 = (decoder.readIndex()); + if (unionIndex495 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(495, null); + } else { + if (unionIndex495 == 1) { + Utf8 charSequence495; + Object oldString495 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(495); + if (oldString495 instanceof Utf8) { + charSequence495 = (decoder).readString(((Utf8) oldString495)); + } else { + charSequence495 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(495, charSequence495); + } else { + throw new RuntimeException(("Illegal union index for 'F495': "+ unionIndex495)); + } + } + int unionIndex496 = (decoder.readIndex()); + if (unionIndex496 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(496, null); + } else { + if (unionIndex496 == 1) { + Utf8 charSequence496; + Object oldString496 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(496); + if (oldString496 instanceof Utf8) { + charSequence496 = (decoder).readString(((Utf8) oldString496)); + } else { + charSequence496 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(496, charSequence496); + } else { + throw new RuntimeException(("Illegal union index for 'F496': "+ unionIndex496)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex497 = (decoder.readIndex()); + if (unionIndex497 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(497, null); + } else { + if (unionIndex497 == 1) { + Utf8 charSequence497; + Object oldString497 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(497); + if (oldString497 instanceof Utf8) { + charSequence497 = (decoder).readString(((Utf8) oldString497)); + } else { + charSequence497 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(497, charSequence497); + } else { + throw new RuntimeException(("Illegal union index for 'F497': "+ unionIndex497)); + } + } + int unionIndex498 = (decoder.readIndex()); + if (unionIndex498 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(498, null); + } else { + if (unionIndex498 == 1) { + Utf8 charSequence498; + Object oldString498 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(498); + if (oldString498 instanceof Utf8) { + charSequence498 = (decoder).readString(((Utf8) oldString498)); + } else { + charSequence498 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(498, charSequence498); + } else { + throw new RuntimeException(("Illegal union index for 'F498': "+ unionIndex498)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex499 = (decoder.readIndex()); + if (unionIndex499 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(499, null); + } else { + if (unionIndex499 == 1) { + Utf8 charSequence499; + Object oldString499 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(499); + if (oldString499 instanceof Utf8) { + charSequence499 = (decoder).readString(((Utf8) oldString499)); + } else { + charSequence499 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(499, charSequence499); + } else { + throw new RuntimeException(("Illegal union index for 'F499': "+ unionIndex499)); + } + } + int unionIndex500 = (decoder.readIndex()); + if (unionIndex500 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(500, null); + } else { + if (unionIndex500 == 1) { + Utf8 charSequence500; + Object oldString500 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(500); + if (oldString500 instanceof Utf8) { + charSequence500 = (decoder).readString(((Utf8) oldString500)); + } else { + charSequence500 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(500, charSequence500); + } else { + throw new RuntimeException(("Illegal union index for 'F500': "+ unionIndex500)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex501 = (decoder.readIndex()); + if (unionIndex501 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(501, null); + } else { + if (unionIndex501 == 1) { + Utf8 charSequence501; + Object oldString501 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(501); + if (oldString501 instanceof Utf8) { + charSequence501 = (decoder).readString(((Utf8) oldString501)); + } else { + charSequence501 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(501, charSequence501); + } else { + throw new RuntimeException(("Illegal union index for 'F501': "+ unionIndex501)); + } + } + int unionIndex502 = (decoder.readIndex()); + if (unionIndex502 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(502, null); + } else { + if (unionIndex502 == 1) { + Utf8 charSequence502; + Object oldString502 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(502); + if (oldString502 instanceof Utf8) { + charSequence502 = (decoder).readString(((Utf8) oldString502)); + } else { + charSequence502 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(502, charSequence502); + } else { + throw new RuntimeException(("Illegal union index for 'F502': "+ unionIndex502)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex503 = (decoder.readIndex()); + if (unionIndex503 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(503, null); + } else { + if (unionIndex503 == 1) { + Utf8 charSequence503; + Object oldString503 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(503); + if (oldString503 instanceof Utf8) { + charSequence503 = (decoder).readString(((Utf8) oldString503)); + } else { + charSequence503 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(503, charSequence503); + } else { + throw new RuntimeException(("Illegal union index for 'F503': "+ unionIndex503)); + } + } + int unionIndex504 = (decoder.readIndex()); + if (unionIndex504 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(504, null); + } else { + if (unionIndex504 == 1) { + Utf8 charSequence504; + Object oldString504 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(504); + if (oldString504 instanceof Utf8) { + charSequence504 = (decoder).readString(((Utf8) oldString504)); + } else { + charSequence504 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(504, charSequence504); + } else { + throw new RuntimeException(("Illegal union index for 'F504': "+ unionIndex504)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex505 = (decoder.readIndex()); + if (unionIndex505 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(505, null); + } else { + if (unionIndex505 == 1) { + Utf8 charSequence505; + Object oldString505 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(505); + if (oldString505 instanceof Utf8) { + charSequence505 = (decoder).readString(((Utf8) oldString505)); + } else { + charSequence505 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(505, charSequence505); + } else { + throw new RuntimeException(("Illegal union index for 'F505': "+ unionIndex505)); + } + } + int unionIndex506 = (decoder.readIndex()); + if (unionIndex506 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(506, null); + } else { + if (unionIndex506 == 1) { + Utf8 charSequence506; + Object oldString506 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(506); + if (oldString506 instanceof Utf8) { + charSequence506 = (decoder).readString(((Utf8) oldString506)); + } else { + charSequence506 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(506, charSequence506); + } else { + throw new RuntimeException(("Illegal union index for 'F506': "+ unionIndex506)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex507 = (decoder.readIndex()); + if (unionIndex507 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(507, null); + } else { + if (unionIndex507 == 1) { + Utf8 charSequence507; + Object oldString507 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(507); + if (oldString507 instanceof Utf8) { + charSequence507 = (decoder).readString(((Utf8) oldString507)); + } else { + charSequence507 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(507, charSequence507); + } else { + throw new RuntimeException(("Illegal union index for 'F507': "+ unionIndex507)); + } + } + int unionIndex508 = (decoder.readIndex()); + if (unionIndex508 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(508, null); + } else { + if (unionIndex508 == 1) { + Utf8 charSequence508; + Object oldString508 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(508); + if (oldString508 instanceof Utf8) { + charSequence508 = (decoder).readString(((Utf8) oldString508)); + } else { + charSequence508 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(508, charSequence508); + } else { + throw new RuntimeException(("Illegal union index for 'F508': "+ unionIndex508)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex509 = (decoder.readIndex()); + if (unionIndex509 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(509, null); + } else { + if (unionIndex509 == 1) { + Utf8 charSequence509; + Object oldString509 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(509); + if (oldString509 instanceof Utf8) { + charSequence509 = (decoder).readString(((Utf8) oldString509)); + } else { + charSequence509 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(509, charSequence509); + } else { + throw new RuntimeException(("Illegal union index for 'F509': "+ unionIndex509)); + } + } + int unionIndex510 = (decoder.readIndex()); + if (unionIndex510 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(510, null); + } else { + if (unionIndex510 == 1) { + Utf8 charSequence510; + Object oldString510 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(510); + if (oldString510 instanceof Utf8) { + charSequence510 = (decoder).readString(((Utf8) oldString510)); + } else { + charSequence510 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(510, charSequence510); + } else { + throw new RuntimeException(("Illegal union index for 'F510': "+ unionIndex510)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex511 = (decoder.readIndex()); + if (unionIndex511 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(511, null); + } else { + if (unionIndex511 == 1) { + Utf8 charSequence511; + Object oldString511 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(511); + if (oldString511 instanceof Utf8) { + charSequence511 = (decoder).readString(((Utf8) oldString511)); + } else { + charSequence511 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(511, charSequence511); + } else { + throw new RuntimeException(("Illegal union index for 'F511': "+ unionIndex511)); + } + } + int unionIndex512 = (decoder.readIndex()); + if (unionIndex512 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(512, null); + } else { + if (unionIndex512 == 1) { + Utf8 charSequence512; + Object oldString512 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(512); + if (oldString512 instanceof Utf8) { + charSequence512 = (decoder).readString(((Utf8) oldString512)); + } else { + charSequence512 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(512, charSequence512); + } else { + throw new RuntimeException(("Illegal union index for 'F512': "+ unionIndex512)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex513 = (decoder.readIndex()); + if (unionIndex513 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(513, null); + } else { + if (unionIndex513 == 1) { + Utf8 charSequence513; + Object oldString513 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(513); + if (oldString513 instanceof Utf8) { + charSequence513 = (decoder).readString(((Utf8) oldString513)); + } else { + charSequence513 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(513, charSequence513); + } else { + throw new RuntimeException(("Illegal union index for 'F513': "+ unionIndex513)); + } + } + int unionIndex514 = (decoder.readIndex()); + if (unionIndex514 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(514, null); + } else { + if (unionIndex514 == 1) { + Utf8 charSequence514; + Object oldString514 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(514); + if (oldString514 instanceof Utf8) { + charSequence514 = (decoder).readString(((Utf8) oldString514)); + } else { + charSequence514 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(514, charSequence514); + } else { + throw new RuntimeException(("Illegal union index for 'F514': "+ unionIndex514)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex515 = (decoder.readIndex()); + if (unionIndex515 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(515, null); + } else { + if (unionIndex515 == 1) { + Utf8 charSequence515; + Object oldString515 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(515); + if (oldString515 instanceof Utf8) { + charSequence515 = (decoder).readString(((Utf8) oldString515)); + } else { + charSequence515 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(515, charSequence515); + } else { + throw new RuntimeException(("Illegal union index for 'F515': "+ unionIndex515)); + } + } + int unionIndex516 = (decoder.readIndex()); + if (unionIndex516 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(516, null); + } else { + if (unionIndex516 == 1) { + Utf8 charSequence516; + Object oldString516 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(516); + if (oldString516 instanceof Utf8) { + charSequence516 = (decoder).readString(((Utf8) oldString516)); + } else { + charSequence516 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(516, charSequence516); + } else { + throw new RuntimeException(("Illegal union index for 'F516': "+ unionIndex516)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex517 = (decoder.readIndex()); + if (unionIndex517 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(517, null); + } else { + if (unionIndex517 == 1) { + Utf8 charSequence517; + Object oldString517 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(517); + if (oldString517 instanceof Utf8) { + charSequence517 = (decoder).readString(((Utf8) oldString517)); + } else { + charSequence517 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(517, charSequence517); + } else { + throw new RuntimeException(("Illegal union index for 'F517': "+ unionIndex517)); + } + } + int unionIndex518 = (decoder.readIndex()); + if (unionIndex518 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(518, null); + } else { + if (unionIndex518 == 1) { + Utf8 charSequence518; + Object oldString518 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(518); + if (oldString518 instanceof Utf8) { + charSequence518 = (decoder).readString(((Utf8) oldString518)); + } else { + charSequence518 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(518, charSequence518); + } else { + throw new RuntimeException(("Illegal union index for 'F518': "+ unionIndex518)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex519 = (decoder.readIndex()); + if (unionIndex519 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(519, null); + } else { + if (unionIndex519 == 1) { + Utf8 charSequence519; + Object oldString519 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(519); + if (oldString519 instanceof Utf8) { + charSequence519 = (decoder).readString(((Utf8) oldString519)); + } else { + charSequence519 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(519, charSequence519); + } else { + throw new RuntimeException(("Illegal union index for 'F519': "+ unionIndex519)); + } + } + int unionIndex520 = (decoder.readIndex()); + if (unionIndex520 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(520, null); + } else { + if (unionIndex520 == 1) { + Utf8 charSequence520; + Object oldString520 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(520); + if (oldString520 instanceof Utf8) { + charSequence520 = (decoder).readString(((Utf8) oldString520)); + } else { + charSequence520 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(520, charSequence520); + } else { + throw new RuntimeException(("Illegal union index for 'F520': "+ unionIndex520)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex521 = (decoder.readIndex()); + if (unionIndex521 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(521, null); + } else { + if (unionIndex521 == 1) { + Utf8 charSequence521; + Object oldString521 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(521); + if (oldString521 instanceof Utf8) { + charSequence521 = (decoder).readString(((Utf8) oldString521)); + } else { + charSequence521 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(521, charSequence521); + } else { + throw new RuntimeException(("Illegal union index for 'F521': "+ unionIndex521)); + } + } + int unionIndex522 = (decoder.readIndex()); + if (unionIndex522 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(522, null); + } else { + if (unionIndex522 == 1) { + Utf8 charSequence522; + Object oldString522 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(522); + if (oldString522 instanceof Utf8) { + charSequence522 = (decoder).readString(((Utf8) oldString522)); + } else { + charSequence522 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(522, charSequence522); + } else { + throw new RuntimeException(("Illegal union index for 'F522': "+ unionIndex522)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex523 = (decoder.readIndex()); + if (unionIndex523 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(523, null); + } else { + if (unionIndex523 == 1) { + Utf8 charSequence523; + Object oldString523 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(523); + if (oldString523 instanceof Utf8) { + charSequence523 = (decoder).readString(((Utf8) oldString523)); + } else { + charSequence523 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(523, charSequence523); + } else { + throw new RuntimeException(("Illegal union index for 'F523': "+ unionIndex523)); + } + } + int unionIndex524 = (decoder.readIndex()); + if (unionIndex524 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(524, null); + } else { + if (unionIndex524 == 1) { + Utf8 charSequence524; + Object oldString524 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(524); + if (oldString524 instanceof Utf8) { + charSequence524 = (decoder).readString(((Utf8) oldString524)); + } else { + charSequence524 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(524, charSequence524); + } else { + throw new RuntimeException(("Illegal union index for 'F524': "+ unionIndex524)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex525 = (decoder.readIndex()); + if (unionIndex525 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(525, null); + } else { + if (unionIndex525 == 1) { + Utf8 charSequence525; + Object oldString525 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(525); + if (oldString525 instanceof Utf8) { + charSequence525 = (decoder).readString(((Utf8) oldString525)); + } else { + charSequence525 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(525, charSequence525); + } else { + throw new RuntimeException(("Illegal union index for 'F525': "+ unionIndex525)); + } + } + int unionIndex526 = (decoder.readIndex()); + if (unionIndex526 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(526, null); + } else { + if (unionIndex526 == 1) { + Utf8 charSequence526; + Object oldString526 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(526); + if (oldString526 instanceof Utf8) { + charSequence526 = (decoder).readString(((Utf8) oldString526)); + } else { + charSequence526 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(526, charSequence526); + } else { + throw new RuntimeException(("Illegal union index for 'F526': "+ unionIndex526)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex527 = (decoder.readIndex()); + if (unionIndex527 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(527, null); + } else { + if (unionIndex527 == 1) { + Utf8 charSequence527; + Object oldString527 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(527); + if (oldString527 instanceof Utf8) { + charSequence527 = (decoder).readString(((Utf8) oldString527)); + } else { + charSequence527 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(527, charSequence527); + } else { + throw new RuntimeException(("Illegal union index for 'F527': "+ unionIndex527)); + } + } + int unionIndex528 = (decoder.readIndex()); + if (unionIndex528 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(528, null); + } else { + if (unionIndex528 == 1) { + Utf8 charSequence528; + Object oldString528 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(528); + if (oldString528 instanceof Utf8) { + charSequence528 = (decoder).readString(((Utf8) oldString528)); + } else { + charSequence528 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(528, charSequence528); + } else { + throw new RuntimeException(("Illegal union index for 'F528': "+ unionIndex528)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex529 = (decoder.readIndex()); + if (unionIndex529 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(529, null); + } else { + if (unionIndex529 == 1) { + Utf8 charSequence529; + Object oldString529 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(529); + if (oldString529 instanceof Utf8) { + charSequence529 = (decoder).readString(((Utf8) oldString529)); + } else { + charSequence529 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(529, charSequence529); + } else { + throw new RuntimeException(("Illegal union index for 'F529': "+ unionIndex529)); + } + } + int unionIndex530 = (decoder.readIndex()); + if (unionIndex530 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(530, null); + } else { + if (unionIndex530 == 1) { + Utf8 charSequence530; + Object oldString530 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(530); + if (oldString530 instanceof Utf8) { + charSequence530 = (decoder).readString(((Utf8) oldString530)); + } else { + charSequence530 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(530, charSequence530); + } else { + throw new RuntimeException(("Illegal union index for 'F530': "+ unionIndex530)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex531 = (decoder.readIndex()); + if (unionIndex531 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(531, null); + } else { + if (unionIndex531 == 1) { + Utf8 charSequence531; + Object oldString531 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(531); + if (oldString531 instanceof Utf8) { + charSequence531 = (decoder).readString(((Utf8) oldString531)); + } else { + charSequence531 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(531, charSequence531); + } else { + throw new RuntimeException(("Illegal union index for 'F531': "+ unionIndex531)); + } + } + int unionIndex532 = (decoder.readIndex()); + if (unionIndex532 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(532, null); + } else { + if (unionIndex532 == 1) { + Utf8 charSequence532; + Object oldString532 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(532); + if (oldString532 instanceof Utf8) { + charSequence532 = (decoder).readString(((Utf8) oldString532)); + } else { + charSequence532 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(532, charSequence532); + } else { + throw new RuntimeException(("Illegal union index for 'F532': "+ unionIndex532)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex533 = (decoder.readIndex()); + if (unionIndex533 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(533, null); + } else { + if (unionIndex533 == 1) { + Utf8 charSequence533; + Object oldString533 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(533); + if (oldString533 instanceof Utf8) { + charSequence533 = (decoder).readString(((Utf8) oldString533)); + } else { + charSequence533 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(533, charSequence533); + } else { + throw new RuntimeException(("Illegal union index for 'F533': "+ unionIndex533)); + } + } + int unionIndex534 = (decoder.readIndex()); + if (unionIndex534 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(534, null); + } else { + if (unionIndex534 == 1) { + Utf8 charSequence534; + Object oldString534 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(534); + if (oldString534 instanceof Utf8) { + charSequence534 = (decoder).readString(((Utf8) oldString534)); + } else { + charSequence534 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(534, charSequence534); + } else { + throw new RuntimeException(("Illegal union index for 'F534': "+ unionIndex534)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex535 = (decoder.readIndex()); + if (unionIndex535 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(535, null); + } else { + if (unionIndex535 == 1) { + Utf8 charSequence535; + Object oldString535 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(535); + if (oldString535 instanceof Utf8) { + charSequence535 = (decoder).readString(((Utf8) oldString535)); + } else { + charSequence535 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(535, charSequence535); + } else { + throw new RuntimeException(("Illegal union index for 'F535': "+ unionIndex535)); + } + } + int unionIndex536 = (decoder.readIndex()); + if (unionIndex536 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(536, null); + } else { + if (unionIndex536 == 1) { + Utf8 charSequence536; + Object oldString536 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(536); + if (oldString536 instanceof Utf8) { + charSequence536 = (decoder).readString(((Utf8) oldString536)); + } else { + charSequence536 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(536, charSequence536); + } else { + throw new RuntimeException(("Illegal union index for 'F536': "+ unionIndex536)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex537 = (decoder.readIndex()); + if (unionIndex537 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(537, null); + } else { + if (unionIndex537 == 1) { + Utf8 charSequence537; + Object oldString537 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(537); + if (oldString537 instanceof Utf8) { + charSequence537 = (decoder).readString(((Utf8) oldString537)); + } else { + charSequence537 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(537, charSequence537); + } else { + throw new RuntimeException(("Illegal union index for 'F537': "+ unionIndex537)); + } + } + int unionIndex538 = (decoder.readIndex()); + if (unionIndex538 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(538, null); + } else { + if (unionIndex538 == 1) { + Utf8 charSequence538; + Object oldString538 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(538); + if (oldString538 instanceof Utf8) { + charSequence538 = (decoder).readString(((Utf8) oldString538)); + } else { + charSequence538 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(538, charSequence538); + } else { + throw new RuntimeException(("Illegal union index for 'F538': "+ unionIndex538)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex539 = (decoder.readIndex()); + if (unionIndex539 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(539, null); + } else { + if (unionIndex539 == 1) { + Utf8 charSequence539; + Object oldString539 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(539); + if (oldString539 instanceof Utf8) { + charSequence539 = (decoder).readString(((Utf8) oldString539)); + } else { + charSequence539 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(539, charSequence539); + } else { + throw new RuntimeException(("Illegal union index for 'F539': "+ unionIndex539)); + } + } + int unionIndex540 = (decoder.readIndex()); + if (unionIndex540 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(540, null); + } else { + if (unionIndex540 == 1) { + Utf8 charSequence540; + Object oldString540 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(540); + if (oldString540 instanceof Utf8) { + charSequence540 = (decoder).readString(((Utf8) oldString540)); + } else { + charSequence540 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(540, charSequence540); + } else { + throw new RuntimeException(("Illegal union index for 'F540': "+ unionIndex540)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex541 = (decoder.readIndex()); + if (unionIndex541 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(541, null); + } else { + if (unionIndex541 == 1) { + Utf8 charSequence541; + Object oldString541 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(541); + if (oldString541 instanceof Utf8) { + charSequence541 = (decoder).readString(((Utf8) oldString541)); + } else { + charSequence541 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(541, charSequence541); + } else { + throw new RuntimeException(("Illegal union index for 'F541': "+ unionIndex541)); + } + } + int unionIndex542 = (decoder.readIndex()); + if (unionIndex542 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(542, null); + } else { + if (unionIndex542 == 1) { + Utf8 charSequence542; + Object oldString542 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(542); + if (oldString542 instanceof Utf8) { + charSequence542 = (decoder).readString(((Utf8) oldString542)); + } else { + charSequence542 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(542, charSequence542); + } else { + throw new RuntimeException(("Illegal union index for 'F542': "+ unionIndex542)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex543 = (decoder.readIndex()); + if (unionIndex543 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(543, null); + } else { + if (unionIndex543 == 1) { + Utf8 charSequence543; + Object oldString543 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(543); + if (oldString543 instanceof Utf8) { + charSequence543 = (decoder).readString(((Utf8) oldString543)); + } else { + charSequence543 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(543, charSequence543); + } else { + throw new RuntimeException(("Illegal union index for 'F543': "+ unionIndex543)); + } + } + int unionIndex544 = (decoder.readIndex()); + if (unionIndex544 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(544, null); + } else { + if (unionIndex544 == 1) { + Utf8 charSequence544; + Object oldString544 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(544); + if (oldString544 instanceof Utf8) { + charSequence544 = (decoder).readString(((Utf8) oldString544)); + } else { + charSequence544 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(544, charSequence544); + } else { + throw new RuntimeException(("Illegal union index for 'F544': "+ unionIndex544)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex545 = (decoder.readIndex()); + if (unionIndex545 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(545, null); + } else { + if (unionIndex545 == 1) { + Utf8 charSequence545; + Object oldString545 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(545); + if (oldString545 instanceof Utf8) { + charSequence545 = (decoder).readString(((Utf8) oldString545)); + } else { + charSequence545 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(545, charSequence545); + } else { + throw new RuntimeException(("Illegal union index for 'F545': "+ unionIndex545)); + } + } + int unionIndex546 = (decoder.readIndex()); + if (unionIndex546 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(546, null); + } else { + if (unionIndex546 == 1) { + Utf8 charSequence546; + Object oldString546 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(546); + if (oldString546 instanceof Utf8) { + charSequence546 = (decoder).readString(((Utf8) oldString546)); + } else { + charSequence546 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(546, charSequence546); + } else { + throw new RuntimeException(("Illegal union index for 'F546': "+ unionIndex546)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex547 = (decoder.readIndex()); + if (unionIndex547 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(547, null); + } else { + if (unionIndex547 == 1) { + Utf8 charSequence547; + Object oldString547 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(547); + if (oldString547 instanceof Utf8) { + charSequence547 = (decoder).readString(((Utf8) oldString547)); + } else { + charSequence547 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(547, charSequence547); + } else { + throw new RuntimeException(("Illegal union index for 'F547': "+ unionIndex547)); + } + } + int unionIndex548 = (decoder.readIndex()); + if (unionIndex548 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(548, null); + } else { + if (unionIndex548 == 1) { + Utf8 charSequence548; + Object oldString548 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(548); + if (oldString548 instanceof Utf8) { + charSequence548 = (decoder).readString(((Utf8) oldString548)); + } else { + charSequence548 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(548, charSequence548); + } else { + throw new RuntimeException(("Illegal union index for 'F548': "+ unionIndex548)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex549 = (decoder.readIndex()); + if (unionIndex549 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(549, null); + } else { + if (unionIndex549 == 1) { + Utf8 charSequence549; + Object oldString549 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(549); + if (oldString549 instanceof Utf8) { + charSequence549 = (decoder).readString(((Utf8) oldString549)); + } else { + charSequence549 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(549, charSequence549); + } else { + throw new RuntimeException(("Illegal union index for 'F549': "+ unionIndex549)); + } + } + int unionIndex550 = (decoder.readIndex()); + if (unionIndex550 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(550, null); + } else { + if (unionIndex550 == 1) { + Utf8 charSequence550; + Object oldString550 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(550); + if (oldString550 instanceof Utf8) { + charSequence550 = (decoder).readString(((Utf8) oldString550)); + } else { + charSequence550 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(550, charSequence550); + } else { + throw new RuntimeException(("Illegal union index for 'F550': "+ unionIndex550)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex551 = (decoder.readIndex()); + if (unionIndex551 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(551, null); + } else { + if (unionIndex551 == 1) { + Utf8 charSequence551; + Object oldString551 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(551); + if (oldString551 instanceof Utf8) { + charSequence551 = (decoder).readString(((Utf8) oldString551)); + } else { + charSequence551 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(551, charSequence551); + } else { + throw new RuntimeException(("Illegal union index for 'F551': "+ unionIndex551)); + } + } + int unionIndex552 = (decoder.readIndex()); + if (unionIndex552 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(552, null); + } else { + if (unionIndex552 == 1) { + Utf8 charSequence552; + Object oldString552 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(552); + if (oldString552 instanceof Utf8) { + charSequence552 = (decoder).readString(((Utf8) oldString552)); + } else { + charSequence552 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(552, charSequence552); + } else { + throw new RuntimeException(("Illegal union index for 'F552': "+ unionIndex552)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex553 = (decoder.readIndex()); + if (unionIndex553 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(553, null); + } else { + if (unionIndex553 == 1) { + Utf8 charSequence553; + Object oldString553 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(553); + if (oldString553 instanceof Utf8) { + charSequence553 = (decoder).readString(((Utf8) oldString553)); + } else { + charSequence553 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(553, charSequence553); + } else { + throw new RuntimeException(("Illegal union index for 'F553': "+ unionIndex553)); + } + } + int unionIndex554 = (decoder.readIndex()); + if (unionIndex554 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(554, null); + } else { + if (unionIndex554 == 1) { + Utf8 charSequence554; + Object oldString554 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(554); + if (oldString554 instanceof Utf8) { + charSequence554 = (decoder).readString(((Utf8) oldString554)); + } else { + charSequence554 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(554, charSequence554); + } else { + throw new RuntimeException(("Illegal union index for 'F554': "+ unionIndex554)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex555 = (decoder.readIndex()); + if (unionIndex555 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(555, null); + } else { + if (unionIndex555 == 1) { + Utf8 charSequence555; + Object oldString555 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(555); + if (oldString555 instanceof Utf8) { + charSequence555 = (decoder).readString(((Utf8) oldString555)); + } else { + charSequence555 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(555, charSequence555); + } else { + throw new RuntimeException(("Illegal union index for 'F555': "+ unionIndex555)); + } + } + int unionIndex556 = (decoder.readIndex()); + if (unionIndex556 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(556, null); + } else { + if (unionIndex556 == 1) { + Utf8 charSequence556; + Object oldString556 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(556); + if (oldString556 instanceof Utf8) { + charSequence556 = (decoder).readString(((Utf8) oldString556)); + } else { + charSequence556 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(556, charSequence556); + } else { + throw new RuntimeException(("Illegal union index for 'F556': "+ unionIndex556)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex557 = (decoder.readIndex()); + if (unionIndex557 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(557, null); + } else { + if (unionIndex557 == 1) { + Utf8 charSequence557; + Object oldString557 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(557); + if (oldString557 instanceof Utf8) { + charSequence557 = (decoder).readString(((Utf8) oldString557)); + } else { + charSequence557 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(557, charSequence557); + } else { + throw new RuntimeException(("Illegal union index for 'F557': "+ unionIndex557)); + } + } + int unionIndex558 = (decoder.readIndex()); + if (unionIndex558 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(558, null); + } else { + if (unionIndex558 == 1) { + Utf8 charSequence558; + Object oldString558 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(558); + if (oldString558 instanceof Utf8) { + charSequence558 = (decoder).readString(((Utf8) oldString558)); + } else { + charSequence558 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(558, charSequence558); + } else { + throw new RuntimeException(("Illegal union index for 'F558': "+ unionIndex558)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex559 = (decoder.readIndex()); + if (unionIndex559 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(559, null); + } else { + if (unionIndex559 == 1) { + Utf8 charSequence559; + Object oldString559 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(559); + if (oldString559 instanceof Utf8) { + charSequence559 = (decoder).readString(((Utf8) oldString559)); + } else { + charSequence559 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(559, charSequence559); + } else { + throw new RuntimeException(("Illegal union index for 'F559': "+ unionIndex559)); + } + } + int unionIndex560 = (decoder.readIndex()); + if (unionIndex560 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(560, null); + } else { + if (unionIndex560 == 1) { + Utf8 charSequence560; + Object oldString560 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(560); + if (oldString560 instanceof Utf8) { + charSequence560 = (decoder).readString(((Utf8) oldString560)); + } else { + charSequence560 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(560, charSequence560); + } else { + throw new RuntimeException(("Illegal union index for 'F560': "+ unionIndex560)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex561 = (decoder.readIndex()); + if (unionIndex561 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(561, null); + } else { + if (unionIndex561 == 1) { + Utf8 charSequence561; + Object oldString561 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(561); + if (oldString561 instanceof Utf8) { + charSequence561 = (decoder).readString(((Utf8) oldString561)); + } else { + charSequence561 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(561, charSequence561); + } else { + throw new RuntimeException(("Illegal union index for 'F561': "+ unionIndex561)); + } + } + int unionIndex562 = (decoder.readIndex()); + if (unionIndex562 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(562, null); + } else { + if (unionIndex562 == 1) { + Utf8 charSequence562; + Object oldString562 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(562); + if (oldString562 instanceof Utf8) { + charSequence562 = (decoder).readString(((Utf8) oldString562)); + } else { + charSequence562 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(562, charSequence562); + } else { + throw new RuntimeException(("Illegal union index for 'F562': "+ unionIndex562)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex563 = (decoder.readIndex()); + if (unionIndex563 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(563, null); + } else { + if (unionIndex563 == 1) { + Utf8 charSequence563; + Object oldString563 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(563); + if (oldString563 instanceof Utf8) { + charSequence563 = (decoder).readString(((Utf8) oldString563)); + } else { + charSequence563 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(563, charSequence563); + } else { + throw new RuntimeException(("Illegal union index for 'F563': "+ unionIndex563)); + } + } + int unionIndex564 = (decoder.readIndex()); + if (unionIndex564 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(564, null); + } else { + if (unionIndex564 == 1) { + Utf8 charSequence564; + Object oldString564 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(564); + if (oldString564 instanceof Utf8) { + charSequence564 = (decoder).readString(((Utf8) oldString564)); + } else { + charSequence564 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(564, charSequence564); + } else { + throw new RuntimeException(("Illegal union index for 'F564': "+ unionIndex564)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex565 = (decoder.readIndex()); + if (unionIndex565 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(565, null); + } else { + if (unionIndex565 == 1) { + Utf8 charSequence565; + Object oldString565 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(565); + if (oldString565 instanceof Utf8) { + charSequence565 = (decoder).readString(((Utf8) oldString565)); + } else { + charSequence565 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(565, charSequence565); + } else { + throw new RuntimeException(("Illegal union index for 'F565': "+ unionIndex565)); + } + } + int unionIndex566 = (decoder.readIndex()); + if (unionIndex566 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(566, null); + } else { + if (unionIndex566 == 1) { + Utf8 charSequence566; + Object oldString566 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(566); + if (oldString566 instanceof Utf8) { + charSequence566 = (decoder).readString(((Utf8) oldString566)); + } else { + charSequence566 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(566, charSequence566); + } else { + throw new RuntimeException(("Illegal union index for 'F566': "+ unionIndex566)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex567 = (decoder.readIndex()); + if (unionIndex567 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(567, null); + } else { + if (unionIndex567 == 1) { + Utf8 charSequence567; + Object oldString567 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(567); + if (oldString567 instanceof Utf8) { + charSequence567 = (decoder).readString(((Utf8) oldString567)); + } else { + charSequence567 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(567, charSequence567); + } else { + throw new RuntimeException(("Illegal union index for 'F567': "+ unionIndex567)); + } + } + int unionIndex568 = (decoder.readIndex()); + if (unionIndex568 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(568, null); + } else { + if (unionIndex568 == 1) { + Utf8 charSequence568; + Object oldString568 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(568); + if (oldString568 instanceof Utf8) { + charSequence568 = (decoder).readString(((Utf8) oldString568)); + } else { + charSequence568 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(568, charSequence568); + } else { + throw new RuntimeException(("Illegal union index for 'F568': "+ unionIndex568)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex569 = (decoder.readIndex()); + if (unionIndex569 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(569, null); + } else { + if (unionIndex569 == 1) { + Utf8 charSequence569; + Object oldString569 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(569); + if (oldString569 instanceof Utf8) { + charSequence569 = (decoder).readString(((Utf8) oldString569)); + } else { + charSequence569 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(569, charSequence569); + } else { + throw new RuntimeException(("Illegal union index for 'F569': "+ unionIndex569)); + } + } + int unionIndex570 = (decoder.readIndex()); + if (unionIndex570 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(570, null); + } else { + if (unionIndex570 == 1) { + Utf8 charSequence570; + Object oldString570 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(570); + if (oldString570 instanceof Utf8) { + charSequence570 = (decoder).readString(((Utf8) oldString570)); + } else { + charSequence570 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(570, charSequence570); + } else { + throw new RuntimeException(("Illegal union index for 'F570': "+ unionIndex570)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex571 = (decoder.readIndex()); + if (unionIndex571 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(571, null); + } else { + if (unionIndex571 == 1) { + Utf8 charSequence571; + Object oldString571 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(571); + if (oldString571 instanceof Utf8) { + charSequence571 = (decoder).readString(((Utf8) oldString571)); + } else { + charSequence571 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(571, charSequence571); + } else { + throw new RuntimeException(("Illegal union index for 'F571': "+ unionIndex571)); + } + } + int unionIndex572 = (decoder.readIndex()); + if (unionIndex572 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(572, null); + } else { + if (unionIndex572 == 1) { + Utf8 charSequence572; + Object oldString572 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(572); + if (oldString572 instanceof Utf8) { + charSequence572 = (decoder).readString(((Utf8) oldString572)); + } else { + charSequence572 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(572, charSequence572); + } else { + throw new RuntimeException(("Illegal union index for 'F572': "+ unionIndex572)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex573 = (decoder.readIndex()); + if (unionIndex573 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(573, null); + } else { + if (unionIndex573 == 1) { + Utf8 charSequence573; + Object oldString573 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(573); + if (oldString573 instanceof Utf8) { + charSequence573 = (decoder).readString(((Utf8) oldString573)); + } else { + charSequence573 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(573, charSequence573); + } else { + throw new RuntimeException(("Illegal union index for 'F573': "+ unionIndex573)); + } + } + int unionIndex574 = (decoder.readIndex()); + if (unionIndex574 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(574, null); + } else { + if (unionIndex574 == 1) { + Utf8 charSequence574; + Object oldString574 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(574); + if (oldString574 instanceof Utf8) { + charSequence574 = (decoder).readString(((Utf8) oldString574)); + } else { + charSequence574 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(574, charSequence574); + } else { + throw new RuntimeException(("Illegal union index for 'F574': "+ unionIndex574)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex575 = (decoder.readIndex()); + if (unionIndex575 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(575, null); + } else { + if (unionIndex575 == 1) { + Utf8 charSequence575; + Object oldString575 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(575); + if (oldString575 instanceof Utf8) { + charSequence575 = (decoder).readString(((Utf8) oldString575)); + } else { + charSequence575 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(575, charSequence575); + } else { + throw new RuntimeException(("Illegal union index for 'F575': "+ unionIndex575)); + } + } + int unionIndex576 = (decoder.readIndex()); + if (unionIndex576 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(576, null); + } else { + if (unionIndex576 == 1) { + Utf8 charSequence576; + Object oldString576 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(576); + if (oldString576 instanceof Utf8) { + charSequence576 = (decoder).readString(((Utf8) oldString576)); + } else { + charSequence576 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(576, charSequence576); + } else { + throw new RuntimeException(("Illegal union index for 'F576': "+ unionIndex576)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex577 = (decoder.readIndex()); + if (unionIndex577 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(577, null); + } else { + if (unionIndex577 == 1) { + Utf8 charSequence577; + Object oldString577 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(577); + if (oldString577 instanceof Utf8) { + charSequence577 = (decoder).readString(((Utf8) oldString577)); + } else { + charSequence577 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(577, charSequence577); + } else { + throw new RuntimeException(("Illegal union index for 'F577': "+ unionIndex577)); + } + } + int unionIndex578 = (decoder.readIndex()); + if (unionIndex578 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(578, null); + } else { + if (unionIndex578 == 1) { + Utf8 charSequence578; + Object oldString578 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(578); + if (oldString578 instanceof Utf8) { + charSequence578 = (decoder).readString(((Utf8) oldString578)); + } else { + charSequence578 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(578, charSequence578); + } else { + throw new RuntimeException(("Illegal union index for 'F578': "+ unionIndex578)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex579 = (decoder.readIndex()); + if (unionIndex579 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(579, null); + } else { + if (unionIndex579 == 1) { + Utf8 charSequence579; + Object oldString579 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(579); + if (oldString579 instanceof Utf8) { + charSequence579 = (decoder).readString(((Utf8) oldString579)); + } else { + charSequence579 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(579, charSequence579); + } else { + throw new RuntimeException(("Illegal union index for 'F579': "+ unionIndex579)); + } + } + int unionIndex580 = (decoder.readIndex()); + if (unionIndex580 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(580, null); + } else { + if (unionIndex580 == 1) { + Utf8 charSequence580; + Object oldString580 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(580); + if (oldString580 instanceof Utf8) { + charSequence580 = (decoder).readString(((Utf8) oldString580)); + } else { + charSequence580 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(580, charSequence580); + } else { + throw new RuntimeException(("Illegal union index for 'F580': "+ unionIndex580)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex581 = (decoder.readIndex()); + if (unionIndex581 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(581, null); + } else { + if (unionIndex581 == 1) { + Utf8 charSequence581; + Object oldString581 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(581); + if (oldString581 instanceof Utf8) { + charSequence581 = (decoder).readString(((Utf8) oldString581)); + } else { + charSequence581 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(581, charSequence581); + } else { + throw new RuntimeException(("Illegal union index for 'F581': "+ unionIndex581)); + } + } + int unionIndex582 = (decoder.readIndex()); + if (unionIndex582 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(582, null); + } else { + if (unionIndex582 == 1) { + Utf8 charSequence582; + Object oldString582 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(582); + if (oldString582 instanceof Utf8) { + charSequence582 = (decoder).readString(((Utf8) oldString582)); + } else { + charSequence582 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(582, charSequence582); + } else { + throw new RuntimeException(("Illegal union index for 'F582': "+ unionIndex582)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex583 = (decoder.readIndex()); + if (unionIndex583 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(583, null); + } else { + if (unionIndex583 == 1) { + Utf8 charSequence583; + Object oldString583 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(583); + if (oldString583 instanceof Utf8) { + charSequence583 = (decoder).readString(((Utf8) oldString583)); + } else { + charSequence583 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(583, charSequence583); + } else { + throw new RuntimeException(("Illegal union index for 'F583': "+ unionIndex583)); + } + } + int unionIndex584 = (decoder.readIndex()); + if (unionIndex584 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(584, null); + } else { + if (unionIndex584 == 1) { + Utf8 charSequence584; + Object oldString584 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(584); + if (oldString584 instanceof Utf8) { + charSequence584 = (decoder).readString(((Utf8) oldString584)); + } else { + charSequence584 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(584, charSequence584); + } else { + throw new RuntimeException(("Illegal union index for 'F584': "+ unionIndex584)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex585 = (decoder.readIndex()); + if (unionIndex585 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(585, null); + } else { + if (unionIndex585 == 1) { + Utf8 charSequence585; + Object oldString585 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(585); + if (oldString585 instanceof Utf8) { + charSequence585 = (decoder).readString(((Utf8) oldString585)); + } else { + charSequence585 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(585, charSequence585); + } else { + throw new RuntimeException(("Illegal union index for 'F585': "+ unionIndex585)); + } + } + int unionIndex586 = (decoder.readIndex()); + if (unionIndex586 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(586, null); + } else { + if (unionIndex586 == 1) { + Utf8 charSequence586; + Object oldString586 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(586); + if (oldString586 instanceof Utf8) { + charSequence586 = (decoder).readString(((Utf8) oldString586)); + } else { + charSequence586 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(586, charSequence586); + } else { + throw new RuntimeException(("Illegal union index for 'F586': "+ unionIndex586)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex587 = (decoder.readIndex()); + if (unionIndex587 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(587, null); + } else { + if (unionIndex587 == 1) { + Utf8 charSequence587; + Object oldString587 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(587); + if (oldString587 instanceof Utf8) { + charSequence587 = (decoder).readString(((Utf8) oldString587)); + } else { + charSequence587 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(587, charSequence587); + } else { + throw new RuntimeException(("Illegal union index for 'F587': "+ unionIndex587)); + } + } + int unionIndex588 = (decoder.readIndex()); + if (unionIndex588 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(588, null); + } else { + if (unionIndex588 == 1) { + Utf8 charSequence588; + Object oldString588 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(588); + if (oldString588 instanceof Utf8) { + charSequence588 = (decoder).readString(((Utf8) oldString588)); + } else { + charSequence588 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(588, charSequence588); + } else { + throw new RuntimeException(("Illegal union index for 'F588': "+ unionIndex588)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex589 = (decoder.readIndex()); + if (unionIndex589 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(589, null); + } else { + if (unionIndex589 == 1) { + Utf8 charSequence589; + Object oldString589 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(589); + if (oldString589 instanceof Utf8) { + charSequence589 = (decoder).readString(((Utf8) oldString589)); + } else { + charSequence589 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(589, charSequence589); + } else { + throw new RuntimeException(("Illegal union index for 'F589': "+ unionIndex589)); + } + } + int unionIndex590 = (decoder.readIndex()); + if (unionIndex590 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(590, null); + } else { + if (unionIndex590 == 1) { + Utf8 charSequence590; + Object oldString590 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(590); + if (oldString590 instanceof Utf8) { + charSequence590 = (decoder).readString(((Utf8) oldString590)); + } else { + charSequence590 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(590, charSequence590); + } else { + throw new RuntimeException(("Illegal union index for 'F590': "+ unionIndex590)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex591 = (decoder.readIndex()); + if (unionIndex591 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(591, null); + } else { + if (unionIndex591 == 1) { + Utf8 charSequence591; + Object oldString591 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(591); + if (oldString591 instanceof Utf8) { + charSequence591 = (decoder).readString(((Utf8) oldString591)); + } else { + charSequence591 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(591, charSequence591); + } else { + throw new RuntimeException(("Illegal union index for 'F591': "+ unionIndex591)); + } + } + int unionIndex592 = (decoder.readIndex()); + if (unionIndex592 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(592, null); + } else { + if (unionIndex592 == 1) { + Utf8 charSequence592; + Object oldString592 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(592); + if (oldString592 instanceof Utf8) { + charSequence592 = (decoder).readString(((Utf8) oldString592)); + } else { + charSequence592 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(592, charSequence592); + } else { + throw new RuntimeException(("Illegal union index for 'F592': "+ unionIndex592)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex593 = (decoder.readIndex()); + if (unionIndex593 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(593, null); + } else { + if (unionIndex593 == 1) { + Utf8 charSequence593; + Object oldString593 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(593); + if (oldString593 instanceof Utf8) { + charSequence593 = (decoder).readString(((Utf8) oldString593)); + } else { + charSequence593 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(593, charSequence593); + } else { + throw new RuntimeException(("Illegal union index for 'F593': "+ unionIndex593)); + } + } + int unionIndex594 = (decoder.readIndex()); + if (unionIndex594 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(594, null); + } else { + if (unionIndex594 == 1) { + Utf8 charSequence594; + Object oldString594 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(594); + if (oldString594 instanceof Utf8) { + charSequence594 = (decoder).readString(((Utf8) oldString594)); + } else { + charSequence594 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(594, charSequence594); + } else { + throw new RuntimeException(("Illegal union index for 'F594': "+ unionIndex594)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex595 = (decoder.readIndex()); + if (unionIndex595 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(595, null); + } else { + if (unionIndex595 == 1) { + Utf8 charSequence595; + Object oldString595 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(595); + if (oldString595 instanceof Utf8) { + charSequence595 = (decoder).readString(((Utf8) oldString595)); + } else { + charSequence595 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(595, charSequence595); + } else { + throw new RuntimeException(("Illegal union index for 'F595': "+ unionIndex595)); + } + } + int unionIndex596 = (decoder.readIndex()); + if (unionIndex596 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(596, null); + } else { + if (unionIndex596 == 1) { + Utf8 charSequence596; + Object oldString596 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(596); + if (oldString596 instanceof Utf8) { + charSequence596 = (decoder).readString(((Utf8) oldString596)); + } else { + charSequence596 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(596, charSequence596); + } else { + throw new RuntimeException(("Illegal union index for 'F596': "+ unionIndex596)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex597 = (decoder.readIndex()); + if (unionIndex597 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(597, null); + } else { + if (unionIndex597 == 1) { + Utf8 charSequence597; + Object oldString597 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(597); + if (oldString597 instanceof Utf8) { + charSequence597 = (decoder).readString(((Utf8) oldString597)); + } else { + charSequence597 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(597, charSequence597); + } else { + throw new RuntimeException(("Illegal union index for 'F597': "+ unionIndex597)); + } + } + int unionIndex598 = (decoder.readIndex()); + if (unionIndex598 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(598, null); + } else { + if (unionIndex598 == 1) { + Utf8 charSequence598; + Object oldString598 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(598); + if (oldString598 instanceof Utf8) { + charSequence598 = (decoder).readString(((Utf8) oldString598)); + } else { + charSequence598 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(598, charSequence598); + } else { + throw new RuntimeException(("Illegal union index for 'F598': "+ unionIndex598)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex599 = (decoder.readIndex()); + if (unionIndex599 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(599, null); + } else { + if (unionIndex599 == 1) { + Utf8 charSequence599; + Object oldString599 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(599); + if (oldString599 instanceof Utf8) { + charSequence599 = (decoder).readString(((Utf8) oldString599)); + } else { + charSequence599 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(599, charSequence599); + } else { + throw new RuntimeException(("Illegal union index for 'F599': "+ unionIndex599)); + } + } + int unionIndex600 = (decoder.readIndex()); + if (unionIndex600 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(600, null); + } else { + if (unionIndex600 == 1) { + Utf8 charSequence600; + Object oldString600 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(600); + if (oldString600 instanceof Utf8) { + charSequence600 = (decoder).readString(((Utf8) oldString600)); + } else { + charSequence600 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(600, charSequence600); + } else { + throw new RuntimeException(("Illegal union index for 'F600': "+ unionIndex600)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex601 = (decoder.readIndex()); + if (unionIndex601 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(601, null); + } else { + if (unionIndex601 == 1) { + Utf8 charSequence601; + Object oldString601 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(601); + if (oldString601 instanceof Utf8) { + charSequence601 = (decoder).readString(((Utf8) oldString601)); + } else { + charSequence601 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(601, charSequence601); + } else { + throw new RuntimeException(("Illegal union index for 'F601': "+ unionIndex601)); + } + } + int unionIndex602 = (decoder.readIndex()); + if (unionIndex602 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(602, null); + } else { + if (unionIndex602 == 1) { + Utf8 charSequence602; + Object oldString602 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(602); + if (oldString602 instanceof Utf8) { + charSequence602 = (decoder).readString(((Utf8) oldString602)); + } else { + charSequence602 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(602, charSequence602); + } else { + throw new RuntimeException(("Illegal union index for 'F602': "+ unionIndex602)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex603 = (decoder.readIndex()); + if (unionIndex603 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(603, null); + } else { + if (unionIndex603 == 1) { + Utf8 charSequence603; + Object oldString603 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(603); + if (oldString603 instanceof Utf8) { + charSequence603 = (decoder).readString(((Utf8) oldString603)); + } else { + charSequence603 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(603, charSequence603); + } else { + throw new RuntimeException(("Illegal union index for 'F603': "+ unionIndex603)); + } + } + int unionIndex604 = (decoder.readIndex()); + if (unionIndex604 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(604, null); + } else { + if (unionIndex604 == 1) { + Utf8 charSequence604; + Object oldString604 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(604); + if (oldString604 instanceof Utf8) { + charSequence604 = (decoder).readString(((Utf8) oldString604)); + } else { + charSequence604 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(604, charSequence604); + } else { + throw new RuntimeException(("Illegal union index for 'F604': "+ unionIndex604)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex605 = (decoder.readIndex()); + if (unionIndex605 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(605, null); + } else { + if (unionIndex605 == 1) { + Utf8 charSequence605; + Object oldString605 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(605); + if (oldString605 instanceof Utf8) { + charSequence605 = (decoder).readString(((Utf8) oldString605)); + } else { + charSequence605 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(605, charSequence605); + } else { + throw new RuntimeException(("Illegal union index for 'F605': "+ unionIndex605)); + } + } + int unionIndex606 = (decoder.readIndex()); + if (unionIndex606 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(606, null); + } else { + if (unionIndex606 == 1) { + Utf8 charSequence606; + Object oldString606 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(606); + if (oldString606 instanceof Utf8) { + charSequence606 = (decoder).readString(((Utf8) oldString606)); + } else { + charSequence606 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(606, charSequence606); + } else { + throw new RuntimeException(("Illegal union index for 'F606': "+ unionIndex606)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex607 = (decoder.readIndex()); + if (unionIndex607 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(607, null); + } else { + if (unionIndex607 == 1) { + Utf8 charSequence607; + Object oldString607 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(607); + if (oldString607 instanceof Utf8) { + charSequence607 = (decoder).readString(((Utf8) oldString607)); + } else { + charSequence607 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(607, charSequence607); + } else { + throw new RuntimeException(("Illegal union index for 'F607': "+ unionIndex607)); + } + } + int unionIndex608 = (decoder.readIndex()); + if (unionIndex608 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(608, null); + } else { + if (unionIndex608 == 1) { + Utf8 charSequence608; + Object oldString608 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(608); + if (oldString608 instanceof Utf8) { + charSequence608 = (decoder).readString(((Utf8) oldString608)); + } else { + charSequence608 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(608, charSequence608); + } else { + throw new RuntimeException(("Illegal union index for 'F608': "+ unionIndex608)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex609 = (decoder.readIndex()); + if (unionIndex609 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(609, null); + } else { + if (unionIndex609 == 1) { + Utf8 charSequence609; + Object oldString609 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(609); + if (oldString609 instanceof Utf8) { + charSequence609 = (decoder).readString(((Utf8) oldString609)); + } else { + charSequence609 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(609, charSequence609); + } else { + throw new RuntimeException(("Illegal union index for 'F609': "+ unionIndex609)); + } + } + int unionIndex610 = (decoder.readIndex()); + if (unionIndex610 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(610, null); + } else { + if (unionIndex610 == 1) { + Utf8 charSequence610; + Object oldString610 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(610); + if (oldString610 instanceof Utf8) { + charSequence610 = (decoder).readString(((Utf8) oldString610)); + } else { + charSequence610 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(610, charSequence610); + } else { + throw new RuntimeException(("Illegal union index for 'F610': "+ unionIndex610)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex611 = (decoder.readIndex()); + if (unionIndex611 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(611, null); + } else { + if (unionIndex611 == 1) { + Utf8 charSequence611; + Object oldString611 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(611); + if (oldString611 instanceof Utf8) { + charSequence611 = (decoder).readString(((Utf8) oldString611)); + } else { + charSequence611 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(611, charSequence611); + } else { + throw new RuntimeException(("Illegal union index for 'F611': "+ unionIndex611)); + } + } + int unionIndex612 = (decoder.readIndex()); + if (unionIndex612 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(612, null); + } else { + if (unionIndex612 == 1) { + Utf8 charSequence612; + Object oldString612 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(612); + if (oldString612 instanceof Utf8) { + charSequence612 = (decoder).readString(((Utf8) oldString612)); + } else { + charSequence612 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(612, charSequence612); + } else { + throw new RuntimeException(("Illegal union index for 'F612': "+ unionIndex612)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex613 = (decoder.readIndex()); + if (unionIndex613 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(613, null); + } else { + if (unionIndex613 == 1) { + Utf8 charSequence613; + Object oldString613 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(613); + if (oldString613 instanceof Utf8) { + charSequence613 = (decoder).readString(((Utf8) oldString613)); + } else { + charSequence613 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(613, charSequence613); + } else { + throw new RuntimeException(("Illegal union index for 'F613': "+ unionIndex613)); + } + } + int unionIndex614 = (decoder.readIndex()); + if (unionIndex614 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(614, null); + } else { + if (unionIndex614 == 1) { + Utf8 charSequence614; + Object oldString614 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(614); + if (oldString614 instanceof Utf8) { + charSequence614 = (decoder).readString(((Utf8) oldString614)); + } else { + charSequence614 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(614, charSequence614); + } else { + throw new RuntimeException(("Illegal union index for 'F614': "+ unionIndex614)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex615 = (decoder.readIndex()); + if (unionIndex615 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(615, null); + } else { + if (unionIndex615 == 1) { + Utf8 charSequence615; + Object oldString615 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(615); + if (oldString615 instanceof Utf8) { + charSequence615 = (decoder).readString(((Utf8) oldString615)); + } else { + charSequence615 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(615, charSequence615); + } else { + throw new RuntimeException(("Illegal union index for 'F615': "+ unionIndex615)); + } + } + int unionIndex616 = (decoder.readIndex()); + if (unionIndex616 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(616, null); + } else { + if (unionIndex616 == 1) { + Utf8 charSequence616; + Object oldString616 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(616); + if (oldString616 instanceof Utf8) { + charSequence616 = (decoder).readString(((Utf8) oldString616)); + } else { + charSequence616 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(616, charSequence616); + } else { + throw new RuntimeException(("Illegal union index for 'F616': "+ unionIndex616)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex617 = (decoder.readIndex()); + if (unionIndex617 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(617, null); + } else { + if (unionIndex617 == 1) { + Utf8 charSequence617; + Object oldString617 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(617); + if (oldString617 instanceof Utf8) { + charSequence617 = (decoder).readString(((Utf8) oldString617)); + } else { + charSequence617 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(617, charSequence617); + } else { + throw new RuntimeException(("Illegal union index for 'F617': "+ unionIndex617)); + } + } + int unionIndex618 = (decoder.readIndex()); + if (unionIndex618 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(618, null); + } else { + if (unionIndex618 == 1) { + Utf8 charSequence618; + Object oldString618 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(618); + if (oldString618 instanceof Utf8) { + charSequence618 = (decoder).readString(((Utf8) oldString618)); + } else { + charSequence618 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(618, charSequence618); + } else { + throw new RuntimeException(("Illegal union index for 'F618': "+ unionIndex618)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex619 = (decoder.readIndex()); + if (unionIndex619 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(619, null); + } else { + if (unionIndex619 == 1) { + Utf8 charSequence619; + Object oldString619 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(619); + if (oldString619 instanceof Utf8) { + charSequence619 = (decoder).readString(((Utf8) oldString619)); + } else { + charSequence619 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(619, charSequence619); + } else { + throw new RuntimeException(("Illegal union index for 'F619': "+ unionIndex619)); + } + } + int unionIndex620 = (decoder.readIndex()); + if (unionIndex620 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(620, null); + } else { + if (unionIndex620 == 1) { + Utf8 charSequence620; + Object oldString620 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(620); + if (oldString620 instanceof Utf8) { + charSequence620 = (decoder).readString(((Utf8) oldString620)); + } else { + charSequence620 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(620, charSequence620); + } else { + throw new RuntimeException(("Illegal union index for 'F620': "+ unionIndex620)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex621 = (decoder.readIndex()); + if (unionIndex621 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(621, null); + } else { + if (unionIndex621 == 1) { + Utf8 charSequence621; + Object oldString621 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(621); + if (oldString621 instanceof Utf8) { + charSequence621 = (decoder).readString(((Utf8) oldString621)); + } else { + charSequence621 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(621, charSequence621); + } else { + throw new RuntimeException(("Illegal union index for 'F621': "+ unionIndex621)); + } + } + int unionIndex622 = (decoder.readIndex()); + if (unionIndex622 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(622, null); + } else { + if (unionIndex622 == 1) { + Utf8 charSequence622; + Object oldString622 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(622); + if (oldString622 instanceof Utf8) { + charSequence622 = (decoder).readString(((Utf8) oldString622)); + } else { + charSequence622 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(622, charSequence622); + } else { + throw new RuntimeException(("Illegal union index for 'F622': "+ unionIndex622)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex623 = (decoder.readIndex()); + if (unionIndex623 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(623, null); + } else { + if (unionIndex623 == 1) { + Utf8 charSequence623; + Object oldString623 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(623); + if (oldString623 instanceof Utf8) { + charSequence623 = (decoder).readString(((Utf8) oldString623)); + } else { + charSequence623 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(623, charSequence623); + } else { + throw new RuntimeException(("Illegal union index for 'F623': "+ unionIndex623)); + } + } + int unionIndex624 = (decoder.readIndex()); + if (unionIndex624 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(624, null); + } else { + if (unionIndex624 == 1) { + Utf8 charSequence624; + Object oldString624 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(624); + if (oldString624 instanceof Utf8) { + charSequence624 = (decoder).readString(((Utf8) oldString624)); + } else { + charSequence624 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(624, charSequence624); + } else { + throw new RuntimeException(("Illegal union index for 'F624': "+ unionIndex624)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex625 = (decoder.readIndex()); + if (unionIndex625 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(625, null); + } else { + if (unionIndex625 == 1) { + Utf8 charSequence625; + Object oldString625 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(625); + if (oldString625 instanceof Utf8) { + charSequence625 = (decoder).readString(((Utf8) oldString625)); + } else { + charSequence625 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(625, charSequence625); + } else { + throw new RuntimeException(("Illegal union index for 'F625': "+ unionIndex625)); + } + } + int unionIndex626 = (decoder.readIndex()); + if (unionIndex626 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(626, null); + } else { + if (unionIndex626 == 1) { + Utf8 charSequence626; + Object oldString626 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(626); + if (oldString626 instanceof Utf8) { + charSequence626 = (decoder).readString(((Utf8) oldString626)); + } else { + charSequence626 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(626, charSequence626); + } else { + throw new RuntimeException(("Illegal union index for 'F626': "+ unionIndex626)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex627 = (decoder.readIndex()); + if (unionIndex627 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(627, null); + } else { + if (unionIndex627 == 1) { + Utf8 charSequence627; + Object oldString627 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(627); + if (oldString627 instanceof Utf8) { + charSequence627 = (decoder).readString(((Utf8) oldString627)); + } else { + charSequence627 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(627, charSequence627); + } else { + throw new RuntimeException(("Illegal union index for 'F627': "+ unionIndex627)); + } + } + int unionIndex628 = (decoder.readIndex()); + if (unionIndex628 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(628, null); + } else { + if (unionIndex628 == 1) { + Utf8 charSequence628; + Object oldString628 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(628); + if (oldString628 instanceof Utf8) { + charSequence628 = (decoder).readString(((Utf8) oldString628)); + } else { + charSequence628 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(628, charSequence628); + } else { + throw new RuntimeException(("Illegal union index for 'F628': "+ unionIndex628)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex629 = (decoder.readIndex()); + if (unionIndex629 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(629, null); + } else { + if (unionIndex629 == 1) { + Utf8 charSequence629; + Object oldString629 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(629); + if (oldString629 instanceof Utf8) { + charSequence629 = (decoder).readString(((Utf8) oldString629)); + } else { + charSequence629 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(629, charSequence629); + } else { + throw new RuntimeException(("Illegal union index for 'F629': "+ unionIndex629)); + } + } + int unionIndex630 = (decoder.readIndex()); + if (unionIndex630 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(630, null); + } else { + if (unionIndex630 == 1) { + Utf8 charSequence630; + Object oldString630 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(630); + if (oldString630 instanceof Utf8) { + charSequence630 = (decoder).readString(((Utf8) oldString630)); + } else { + charSequence630 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(630, charSequence630); + } else { + throw new RuntimeException(("Illegal union index for 'F630': "+ unionIndex630)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex631 = (decoder.readIndex()); + if (unionIndex631 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(631, null); + } else { + if (unionIndex631 == 1) { + Utf8 charSequence631; + Object oldString631 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(631); + if (oldString631 instanceof Utf8) { + charSequence631 = (decoder).readString(((Utf8) oldString631)); + } else { + charSequence631 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(631, charSequence631); + } else { + throw new RuntimeException(("Illegal union index for 'F631': "+ unionIndex631)); + } + } + int unionIndex632 = (decoder.readIndex()); + if (unionIndex632 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(632, null); + } else { + if (unionIndex632 == 1) { + Utf8 charSequence632; + Object oldString632 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(632); + if (oldString632 instanceof Utf8) { + charSequence632 = (decoder).readString(((Utf8) oldString632)); + } else { + charSequence632 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(632, charSequence632); + } else { + throw new RuntimeException(("Illegal union index for 'F632': "+ unionIndex632)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex633 = (decoder.readIndex()); + if (unionIndex633 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(633, null); + } else { + if (unionIndex633 == 1) { + Utf8 charSequence633; + Object oldString633 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(633); + if (oldString633 instanceof Utf8) { + charSequence633 = (decoder).readString(((Utf8) oldString633)); + } else { + charSequence633 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(633, charSequence633); + } else { + throw new RuntimeException(("Illegal union index for 'F633': "+ unionIndex633)); + } + } + int unionIndex634 = (decoder.readIndex()); + if (unionIndex634 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(634, null); + } else { + if (unionIndex634 == 1) { + Utf8 charSequence634; + Object oldString634 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(634); + if (oldString634 instanceof Utf8) { + charSequence634 = (decoder).readString(((Utf8) oldString634)); + } else { + charSequence634 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(634, charSequence634); + } else { + throw new RuntimeException(("Illegal union index for 'F634': "+ unionIndex634)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex635 = (decoder.readIndex()); + if (unionIndex635 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(635, null); + } else { + if (unionIndex635 == 1) { + Utf8 charSequence635; + Object oldString635 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(635); + if (oldString635 instanceof Utf8) { + charSequence635 = (decoder).readString(((Utf8) oldString635)); + } else { + charSequence635 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(635, charSequence635); + } else { + throw new RuntimeException(("Illegal union index for 'F635': "+ unionIndex635)); + } + } + int unionIndex636 = (decoder.readIndex()); + if (unionIndex636 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(636, null); + } else { + if (unionIndex636 == 1) { + Utf8 charSequence636; + Object oldString636 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(636); + if (oldString636 instanceof Utf8) { + charSequence636 = (decoder).readString(((Utf8) oldString636)); + } else { + charSequence636 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(636, charSequence636); + } else { + throw new RuntimeException(("Illegal union index for 'F636': "+ unionIndex636)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex637 = (decoder.readIndex()); + if (unionIndex637 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(637, null); + } else { + if (unionIndex637 == 1) { + Utf8 charSequence637; + Object oldString637 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(637); + if (oldString637 instanceof Utf8) { + charSequence637 = (decoder).readString(((Utf8) oldString637)); + } else { + charSequence637 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(637, charSequence637); + } else { + throw new RuntimeException(("Illegal union index for 'F637': "+ unionIndex637)); + } + } + int unionIndex638 = (decoder.readIndex()); + if (unionIndex638 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(638, null); + } else { + if (unionIndex638 == 1) { + Utf8 charSequence638; + Object oldString638 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(638); + if (oldString638 instanceof Utf8) { + charSequence638 = (decoder).readString(((Utf8) oldString638)); + } else { + charSequence638 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(638, charSequence638); + } else { + throw new RuntimeException(("Illegal union index for 'F638': "+ unionIndex638)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex639 = (decoder.readIndex()); + if (unionIndex639 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(639, null); + } else { + if (unionIndex639 == 1) { + Utf8 charSequence639; + Object oldString639 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(639); + if (oldString639 instanceof Utf8) { + charSequence639 = (decoder).readString(((Utf8) oldString639)); + } else { + charSequence639 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(639, charSequence639); + } else { + throw new RuntimeException(("Illegal union index for 'F639': "+ unionIndex639)); + } + } + int unionIndex640 = (decoder.readIndex()); + if (unionIndex640 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(640, null); + } else { + if (unionIndex640 == 1) { + Utf8 charSequence640; + Object oldString640 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(640); + if (oldString640 instanceof Utf8) { + charSequence640 = (decoder).readString(((Utf8) oldString640)); + } else { + charSequence640 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(640, charSequence640); + } else { + throw new RuntimeException(("Illegal union index for 'F640': "+ unionIndex640)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex641 = (decoder.readIndex()); + if (unionIndex641 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(641, null); + } else { + if (unionIndex641 == 1) { + Utf8 charSequence641; + Object oldString641 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(641); + if (oldString641 instanceof Utf8) { + charSequence641 = (decoder).readString(((Utf8) oldString641)); + } else { + charSequence641 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(641, charSequence641); + } else { + throw new RuntimeException(("Illegal union index for 'F641': "+ unionIndex641)); + } + } + int unionIndex642 = (decoder.readIndex()); + if (unionIndex642 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(642, null); + } else { + if (unionIndex642 == 1) { + Utf8 charSequence642; + Object oldString642 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(642); + if (oldString642 instanceof Utf8) { + charSequence642 = (decoder).readString(((Utf8) oldString642)); + } else { + charSequence642 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(642, charSequence642); + } else { + throw new RuntimeException(("Illegal union index for 'F642': "+ unionIndex642)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex643 = (decoder.readIndex()); + if (unionIndex643 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(643, null); + } else { + if (unionIndex643 == 1) { + Utf8 charSequence643; + Object oldString643 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(643); + if (oldString643 instanceof Utf8) { + charSequence643 = (decoder).readString(((Utf8) oldString643)); + } else { + charSequence643 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(643, charSequence643); + } else { + throw new RuntimeException(("Illegal union index for 'F643': "+ unionIndex643)); + } + } + int unionIndex644 = (decoder.readIndex()); + if (unionIndex644 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(644, null); + } else { + if (unionIndex644 == 1) { + Utf8 charSequence644; + Object oldString644 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(644); + if (oldString644 instanceof Utf8) { + charSequence644 = (decoder).readString(((Utf8) oldString644)); + } else { + charSequence644 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(644, charSequence644); + } else { + throw new RuntimeException(("Illegal union index for 'F644': "+ unionIndex644)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex645 = (decoder.readIndex()); + if (unionIndex645 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(645, null); + } else { + if (unionIndex645 == 1) { + Utf8 charSequence645; + Object oldString645 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(645); + if (oldString645 instanceof Utf8) { + charSequence645 = (decoder).readString(((Utf8) oldString645)); + } else { + charSequence645 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(645, charSequence645); + } else { + throw new RuntimeException(("Illegal union index for 'F645': "+ unionIndex645)); + } + } + int unionIndex646 = (decoder.readIndex()); + if (unionIndex646 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(646, null); + } else { + if (unionIndex646 == 1) { + Utf8 charSequence646; + Object oldString646 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(646); + if (oldString646 instanceof Utf8) { + charSequence646 = (decoder).readString(((Utf8) oldString646)); + } else { + charSequence646 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(646, charSequence646); + } else { + throw new RuntimeException(("Illegal union index for 'F646': "+ unionIndex646)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex647 = (decoder.readIndex()); + if (unionIndex647 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(647, null); + } else { + if (unionIndex647 == 1) { + Utf8 charSequence647; + Object oldString647 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(647); + if (oldString647 instanceof Utf8) { + charSequence647 = (decoder).readString(((Utf8) oldString647)); + } else { + charSequence647 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(647, charSequence647); + } else { + throw new RuntimeException(("Illegal union index for 'F647': "+ unionIndex647)); + } + } + int unionIndex648 = (decoder.readIndex()); + if (unionIndex648 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(648, null); + } else { + if (unionIndex648 == 1) { + Utf8 charSequence648; + Object oldString648 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(648); + if (oldString648 instanceof Utf8) { + charSequence648 = (decoder).readString(((Utf8) oldString648)); + } else { + charSequence648 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(648, charSequence648); + } else { + throw new RuntimeException(("Illegal union index for 'F648': "+ unionIndex648)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex649 = (decoder.readIndex()); + if (unionIndex649 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(649, null); + } else { + if (unionIndex649 == 1) { + Utf8 charSequence649; + Object oldString649 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(649); + if (oldString649 instanceof Utf8) { + charSequence649 = (decoder).readString(((Utf8) oldString649)); + } else { + charSequence649 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(649, charSequence649); + } else { + throw new RuntimeException(("Illegal union index for 'F649': "+ unionIndex649)); + } + } + int unionIndex650 = (decoder.readIndex()); + if (unionIndex650 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(650, null); + } else { + if (unionIndex650 == 1) { + Utf8 charSequence650; + Object oldString650 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(650); + if (oldString650 instanceof Utf8) { + charSequence650 = (decoder).readString(((Utf8) oldString650)); + } else { + charSequence650 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(650, charSequence650); + } else { + throw new RuntimeException(("Illegal union index for 'F650': "+ unionIndex650)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex651 = (decoder.readIndex()); + if (unionIndex651 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(651, null); + } else { + if (unionIndex651 == 1) { + Utf8 charSequence651; + Object oldString651 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(651); + if (oldString651 instanceof Utf8) { + charSequence651 = (decoder).readString(((Utf8) oldString651)); + } else { + charSequence651 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(651, charSequence651); + } else { + throw new RuntimeException(("Illegal union index for 'F651': "+ unionIndex651)); + } + } + int unionIndex652 = (decoder.readIndex()); + if (unionIndex652 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(652, null); + } else { + if (unionIndex652 == 1) { + Utf8 charSequence652; + Object oldString652 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(652); + if (oldString652 instanceof Utf8) { + charSequence652 = (decoder).readString(((Utf8) oldString652)); + } else { + charSequence652 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(652, charSequence652); + } else { + throw new RuntimeException(("Illegal union index for 'F652': "+ unionIndex652)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex653 = (decoder.readIndex()); + if (unionIndex653 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(653, null); + } else { + if (unionIndex653 == 1) { + Utf8 charSequence653; + Object oldString653 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(653); + if (oldString653 instanceof Utf8) { + charSequence653 = (decoder).readString(((Utf8) oldString653)); + } else { + charSequence653 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(653, charSequence653); + } else { + throw new RuntimeException(("Illegal union index for 'F653': "+ unionIndex653)); + } + } + int unionIndex654 = (decoder.readIndex()); + if (unionIndex654 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(654, null); + } else { + if (unionIndex654 == 1) { + Utf8 charSequence654; + Object oldString654 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(654); + if (oldString654 instanceof Utf8) { + charSequence654 = (decoder).readString(((Utf8) oldString654)); + } else { + charSequence654 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(654, charSequence654); + } else { + throw new RuntimeException(("Illegal union index for 'F654': "+ unionIndex654)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex655 = (decoder.readIndex()); + if (unionIndex655 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(655, null); + } else { + if (unionIndex655 == 1) { + Utf8 charSequence655; + Object oldString655 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(655); + if (oldString655 instanceof Utf8) { + charSequence655 = (decoder).readString(((Utf8) oldString655)); + } else { + charSequence655 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(655, charSequence655); + } else { + throw new RuntimeException(("Illegal union index for 'F655': "+ unionIndex655)); + } + } + int unionIndex656 = (decoder.readIndex()); + if (unionIndex656 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(656, null); + } else { + if (unionIndex656 == 1) { + Utf8 charSequence656; + Object oldString656 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(656); + if (oldString656 instanceof Utf8) { + charSequence656 = (decoder).readString(((Utf8) oldString656)); + } else { + charSequence656 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(656, charSequence656); + } else { + throw new RuntimeException(("Illegal union index for 'F656': "+ unionIndex656)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex657 = (decoder.readIndex()); + if (unionIndex657 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(657, null); + } else { + if (unionIndex657 == 1) { + Utf8 charSequence657; + Object oldString657 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(657); + if (oldString657 instanceof Utf8) { + charSequence657 = (decoder).readString(((Utf8) oldString657)); + } else { + charSequence657 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(657, charSequence657); + } else { + throw new RuntimeException(("Illegal union index for 'F657': "+ unionIndex657)); + } + } + int unionIndex658 = (decoder.readIndex()); + if (unionIndex658 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(658, null); + } else { + if (unionIndex658 == 1) { + Utf8 charSequence658; + Object oldString658 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(658); + if (oldString658 instanceof Utf8) { + charSequence658 = (decoder).readString(((Utf8) oldString658)); + } else { + charSequence658 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(658, charSequence658); + } else { + throw new RuntimeException(("Illegal union index for 'F658': "+ unionIndex658)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex659 = (decoder.readIndex()); + if (unionIndex659 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(659, null); + } else { + if (unionIndex659 == 1) { + Utf8 charSequence659; + Object oldString659 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(659); + if (oldString659 instanceof Utf8) { + charSequence659 = (decoder).readString(((Utf8) oldString659)); + } else { + charSequence659 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(659, charSequence659); + } else { + throw new RuntimeException(("Illegal union index for 'F659': "+ unionIndex659)); + } + } + int unionIndex660 = (decoder.readIndex()); + if (unionIndex660 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(660, null); + } else { + if (unionIndex660 == 1) { + Utf8 charSequence660; + Object oldString660 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(660); + if (oldString660 instanceof Utf8) { + charSequence660 = (decoder).readString(((Utf8) oldString660)); + } else { + charSequence660 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(660, charSequence660); + } else { + throw new RuntimeException(("Illegal union index for 'F660': "+ unionIndex660)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex661 = (decoder.readIndex()); + if (unionIndex661 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(661, null); + } else { + if (unionIndex661 == 1) { + Utf8 charSequence661; + Object oldString661 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(661); + if (oldString661 instanceof Utf8) { + charSequence661 = (decoder).readString(((Utf8) oldString661)); + } else { + charSequence661 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(661, charSequence661); + } else { + throw new RuntimeException(("Illegal union index for 'F661': "+ unionIndex661)); + } + } + int unionIndex662 = (decoder.readIndex()); + if (unionIndex662 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(662, null); + } else { + if (unionIndex662 == 1) { + Utf8 charSequence662; + Object oldString662 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(662); + if (oldString662 instanceof Utf8) { + charSequence662 = (decoder).readString(((Utf8) oldString662)); + } else { + charSequence662 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(662, charSequence662); + } else { + throw new RuntimeException(("Illegal union index for 'F662': "+ unionIndex662)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex663 = (decoder.readIndex()); + if (unionIndex663 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(663, null); + } else { + if (unionIndex663 == 1) { + Utf8 charSequence663; + Object oldString663 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(663); + if (oldString663 instanceof Utf8) { + charSequence663 = (decoder).readString(((Utf8) oldString663)); + } else { + charSequence663 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(663, charSequence663); + } else { + throw new RuntimeException(("Illegal union index for 'F663': "+ unionIndex663)); + } + } + int unionIndex664 = (decoder.readIndex()); + if (unionIndex664 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(664, null); + } else { + if (unionIndex664 == 1) { + Utf8 charSequence664; + Object oldString664 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(664); + if (oldString664 instanceof Utf8) { + charSequence664 = (decoder).readString(((Utf8) oldString664)); + } else { + charSequence664 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(664, charSequence664); + } else { + throw new RuntimeException(("Illegal union index for 'F664': "+ unionIndex664)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex665 = (decoder.readIndex()); + if (unionIndex665 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(665, null); + } else { + if (unionIndex665 == 1) { + Utf8 charSequence665; + Object oldString665 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(665); + if (oldString665 instanceof Utf8) { + charSequence665 = (decoder).readString(((Utf8) oldString665)); + } else { + charSequence665 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(665, charSequence665); + } else { + throw new RuntimeException(("Illegal union index for 'F665': "+ unionIndex665)); + } + } + int unionIndex666 = (decoder.readIndex()); + if (unionIndex666 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(666, null); + } else { + if (unionIndex666 == 1) { + Utf8 charSequence666; + Object oldString666 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(666); + if (oldString666 instanceof Utf8) { + charSequence666 = (decoder).readString(((Utf8) oldString666)); + } else { + charSequence666 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(666, charSequence666); + } else { + throw new RuntimeException(("Illegal union index for 'F666': "+ unionIndex666)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex667 = (decoder.readIndex()); + if (unionIndex667 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(667, null); + } else { + if (unionIndex667 == 1) { + Utf8 charSequence667; + Object oldString667 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(667); + if (oldString667 instanceof Utf8) { + charSequence667 = (decoder).readString(((Utf8) oldString667)); + } else { + charSequence667 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(667, charSequence667); + } else { + throw new RuntimeException(("Illegal union index for 'F667': "+ unionIndex667)); + } + } + int unionIndex668 = (decoder.readIndex()); + if (unionIndex668 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(668, null); + } else { + if (unionIndex668 == 1) { + Utf8 charSequence668; + Object oldString668 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(668); + if (oldString668 instanceof Utf8) { + charSequence668 = (decoder).readString(((Utf8) oldString668)); + } else { + charSequence668 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(668, charSequence668); + } else { + throw new RuntimeException(("Illegal union index for 'F668': "+ unionIndex668)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex669 = (decoder.readIndex()); + if (unionIndex669 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(669, null); + } else { + if (unionIndex669 == 1) { + Utf8 charSequence669; + Object oldString669 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(669); + if (oldString669 instanceof Utf8) { + charSequence669 = (decoder).readString(((Utf8) oldString669)); + } else { + charSequence669 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(669, charSequence669); + } else { + throw new RuntimeException(("Illegal union index for 'F669': "+ unionIndex669)); + } + } + int unionIndex670 = (decoder.readIndex()); + if (unionIndex670 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(670, null); + } else { + if (unionIndex670 == 1) { + Utf8 charSequence670; + Object oldString670 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(670); + if (oldString670 instanceof Utf8) { + charSequence670 = (decoder).readString(((Utf8) oldString670)); + } else { + charSequence670 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(670, charSequence670); + } else { + throw new RuntimeException(("Illegal union index for 'F670': "+ unionIndex670)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex671 = (decoder.readIndex()); + if (unionIndex671 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(671, null); + } else { + if (unionIndex671 == 1) { + Utf8 charSequence671; + Object oldString671 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(671); + if (oldString671 instanceof Utf8) { + charSequence671 = (decoder).readString(((Utf8) oldString671)); + } else { + charSequence671 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(671, charSequence671); + } else { + throw new RuntimeException(("Illegal union index for 'F671': "+ unionIndex671)); + } + } + int unionIndex672 = (decoder.readIndex()); + if (unionIndex672 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(672, null); + } else { + if (unionIndex672 == 1) { + Utf8 charSequence672; + Object oldString672 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(672); + if (oldString672 instanceof Utf8) { + charSequence672 = (decoder).readString(((Utf8) oldString672)); + } else { + charSequence672 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(672, charSequence672); + } else { + throw new RuntimeException(("Illegal union index for 'F672': "+ unionIndex672)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex673 = (decoder.readIndex()); + if (unionIndex673 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(673, null); + } else { + if (unionIndex673 == 1) { + Utf8 charSequence673; + Object oldString673 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(673); + if (oldString673 instanceof Utf8) { + charSequence673 = (decoder).readString(((Utf8) oldString673)); + } else { + charSequence673 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(673, charSequence673); + } else { + throw new RuntimeException(("Illegal union index for 'F673': "+ unionIndex673)); + } + } + int unionIndex674 = (decoder.readIndex()); + if (unionIndex674 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(674, null); + } else { + if (unionIndex674 == 1) { + Utf8 charSequence674; + Object oldString674 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(674); + if (oldString674 instanceof Utf8) { + charSequence674 = (decoder).readString(((Utf8) oldString674)); + } else { + charSequence674 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(674, charSequence674); + } else { + throw new RuntimeException(("Illegal union index for 'F674': "+ unionIndex674)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex675 = (decoder.readIndex()); + if (unionIndex675 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(675, null); + } else { + if (unionIndex675 == 1) { + Utf8 charSequence675; + Object oldString675 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(675); + if (oldString675 instanceof Utf8) { + charSequence675 = (decoder).readString(((Utf8) oldString675)); + } else { + charSequence675 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(675, charSequence675); + } else { + throw new RuntimeException(("Illegal union index for 'F675': "+ unionIndex675)); + } + } + int unionIndex676 = (decoder.readIndex()); + if (unionIndex676 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(676, null); + } else { + if (unionIndex676 == 1) { + Utf8 charSequence676; + Object oldString676 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(676); + if (oldString676 instanceof Utf8) { + charSequence676 = (decoder).readString(((Utf8) oldString676)); + } else { + charSequence676 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(676, charSequence676); + } else { + throw new RuntimeException(("Illegal union index for 'F676': "+ unionIndex676)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex677 = (decoder.readIndex()); + if (unionIndex677 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(677, null); + } else { + if (unionIndex677 == 1) { + Utf8 charSequence677; + Object oldString677 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(677); + if (oldString677 instanceof Utf8) { + charSequence677 = (decoder).readString(((Utf8) oldString677)); + } else { + charSequence677 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(677, charSequence677); + } else { + throw new RuntimeException(("Illegal union index for 'F677': "+ unionIndex677)); + } + } + int unionIndex678 = (decoder.readIndex()); + if (unionIndex678 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(678, null); + } else { + if (unionIndex678 == 1) { + Utf8 charSequence678; + Object oldString678 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(678); + if (oldString678 instanceof Utf8) { + charSequence678 = (decoder).readString(((Utf8) oldString678)); + } else { + charSequence678 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(678, charSequence678); + } else { + throw new RuntimeException(("Illegal union index for 'F678': "+ unionIndex678)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex679 = (decoder.readIndex()); + if (unionIndex679 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(679, null); + } else { + if (unionIndex679 == 1) { + Utf8 charSequence679; + Object oldString679 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(679); + if (oldString679 instanceof Utf8) { + charSequence679 = (decoder).readString(((Utf8) oldString679)); + } else { + charSequence679 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(679, charSequence679); + } else { + throw new RuntimeException(("Illegal union index for 'F679': "+ unionIndex679)); + } + } + int unionIndex680 = (decoder.readIndex()); + if (unionIndex680 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(680, null); + } else { + if (unionIndex680 == 1) { + Utf8 charSequence680; + Object oldString680 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(680); + if (oldString680 instanceof Utf8) { + charSequence680 = (decoder).readString(((Utf8) oldString680)); + } else { + charSequence680 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(680, charSequence680); + } else { + throw new RuntimeException(("Illegal union index for 'F680': "+ unionIndex680)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex681 = (decoder.readIndex()); + if (unionIndex681 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(681, null); + } else { + if (unionIndex681 == 1) { + Utf8 charSequence681; + Object oldString681 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(681); + if (oldString681 instanceof Utf8) { + charSequence681 = (decoder).readString(((Utf8) oldString681)); + } else { + charSequence681 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(681, charSequence681); + } else { + throw new RuntimeException(("Illegal union index for 'F681': "+ unionIndex681)); + } + } + int unionIndex682 = (decoder.readIndex()); + if (unionIndex682 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(682, null); + } else { + if (unionIndex682 == 1) { + Utf8 charSequence682; + Object oldString682 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(682); + if (oldString682 instanceof Utf8) { + charSequence682 = (decoder).readString(((Utf8) oldString682)); + } else { + charSequence682 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(682, charSequence682); + } else { + throw new RuntimeException(("Illegal union index for 'F682': "+ unionIndex682)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex683 = (decoder.readIndex()); + if (unionIndex683 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(683, null); + } else { + if (unionIndex683 == 1) { + Utf8 charSequence683; + Object oldString683 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(683); + if (oldString683 instanceof Utf8) { + charSequence683 = (decoder).readString(((Utf8) oldString683)); + } else { + charSequence683 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(683, charSequence683); + } else { + throw new RuntimeException(("Illegal union index for 'F683': "+ unionIndex683)); + } + } + int unionIndex684 = (decoder.readIndex()); + if (unionIndex684 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(684, null); + } else { + if (unionIndex684 == 1) { + Utf8 charSequence684; + Object oldString684 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(684); + if (oldString684 instanceof Utf8) { + charSequence684 = (decoder).readString(((Utf8) oldString684)); + } else { + charSequence684 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(684, charSequence684); + } else { + throw new RuntimeException(("Illegal union index for 'F684': "+ unionIndex684)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex685 = (decoder.readIndex()); + if (unionIndex685 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(685, null); + } else { + if (unionIndex685 == 1) { + Utf8 charSequence685; + Object oldString685 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(685); + if (oldString685 instanceof Utf8) { + charSequence685 = (decoder).readString(((Utf8) oldString685)); + } else { + charSequence685 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(685, charSequence685); + } else { + throw new RuntimeException(("Illegal union index for 'F685': "+ unionIndex685)); + } + } + int unionIndex686 = (decoder.readIndex()); + if (unionIndex686 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(686, null); + } else { + if (unionIndex686 == 1) { + Utf8 charSequence686; + Object oldString686 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(686); + if (oldString686 instanceof Utf8) { + charSequence686 = (decoder).readString(((Utf8) oldString686)); + } else { + charSequence686 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(686, charSequence686); + } else { + throw new RuntimeException(("Illegal union index for 'F686': "+ unionIndex686)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex687 = (decoder.readIndex()); + if (unionIndex687 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(687, null); + } else { + if (unionIndex687 == 1) { + Utf8 charSequence687; + Object oldString687 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(687); + if (oldString687 instanceof Utf8) { + charSequence687 = (decoder).readString(((Utf8) oldString687)); + } else { + charSequence687 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(687, charSequence687); + } else { + throw new RuntimeException(("Illegal union index for 'F687': "+ unionIndex687)); + } + } + int unionIndex688 = (decoder.readIndex()); + if (unionIndex688 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(688, null); + } else { + if (unionIndex688 == 1) { + Utf8 charSequence688; + Object oldString688 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(688); + if (oldString688 instanceof Utf8) { + charSequence688 = (decoder).readString(((Utf8) oldString688)); + } else { + charSequence688 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(688, charSequence688); + } else { + throw new RuntimeException(("Illegal union index for 'F688': "+ unionIndex688)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex689 = (decoder.readIndex()); + if (unionIndex689 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(689, null); + } else { + if (unionIndex689 == 1) { + Utf8 charSequence689; + Object oldString689 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(689); + if (oldString689 instanceof Utf8) { + charSequence689 = (decoder).readString(((Utf8) oldString689)); + } else { + charSequence689 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(689, charSequence689); + } else { + throw new RuntimeException(("Illegal union index for 'F689': "+ unionIndex689)); + } + } + int unionIndex690 = (decoder.readIndex()); + if (unionIndex690 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(690, null); + } else { + if (unionIndex690 == 1) { + Utf8 charSequence690; + Object oldString690 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(690); + if (oldString690 instanceof Utf8) { + charSequence690 = (decoder).readString(((Utf8) oldString690)); + } else { + charSequence690 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(690, charSequence690); + } else { + throw new RuntimeException(("Illegal union index for 'F690': "+ unionIndex690)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex691 = (decoder.readIndex()); + if (unionIndex691 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(691, null); + } else { + if (unionIndex691 == 1) { + Utf8 charSequence691; + Object oldString691 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(691); + if (oldString691 instanceof Utf8) { + charSequence691 = (decoder).readString(((Utf8) oldString691)); + } else { + charSequence691 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(691, charSequence691); + } else { + throw new RuntimeException(("Illegal union index for 'F691': "+ unionIndex691)); + } + } + int unionIndex692 = (decoder.readIndex()); + if (unionIndex692 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(692, null); + } else { + if (unionIndex692 == 1) { + Utf8 charSequence692; + Object oldString692 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(692); + if (oldString692 instanceof Utf8) { + charSequence692 = (decoder).readString(((Utf8) oldString692)); + } else { + charSequence692 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(692, charSequence692); + } else { + throw new RuntimeException(("Illegal union index for 'F692': "+ unionIndex692)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex693 = (decoder.readIndex()); + if (unionIndex693 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(693, null); + } else { + if (unionIndex693 == 1) { + Utf8 charSequence693; + Object oldString693 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(693); + if (oldString693 instanceof Utf8) { + charSequence693 = (decoder).readString(((Utf8) oldString693)); + } else { + charSequence693 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(693, charSequence693); + } else { + throw new RuntimeException(("Illegal union index for 'F693': "+ unionIndex693)); + } + } + int unionIndex694 = (decoder.readIndex()); + if (unionIndex694 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(694, null); + } else { + if (unionIndex694 == 1) { + Utf8 charSequence694; + Object oldString694 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(694); + if (oldString694 instanceof Utf8) { + charSequence694 = (decoder).readString(((Utf8) oldString694)); + } else { + charSequence694 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(694, charSequence694); + } else { + throw new RuntimeException(("Illegal union index for 'F694': "+ unionIndex694)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex695 = (decoder.readIndex()); + if (unionIndex695 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(695, null); + } else { + if (unionIndex695 == 1) { + Utf8 charSequence695; + Object oldString695 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(695); + if (oldString695 instanceof Utf8) { + charSequence695 = (decoder).readString(((Utf8) oldString695)); + } else { + charSequence695 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(695, charSequence695); + } else { + throw new RuntimeException(("Illegal union index for 'F695': "+ unionIndex695)); + } + } + int unionIndex696 = (decoder.readIndex()); + if (unionIndex696 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(696, null); + } else { + if (unionIndex696 == 1) { + Utf8 charSequence696; + Object oldString696 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(696); + if (oldString696 instanceof Utf8) { + charSequence696 = (decoder).readString(((Utf8) oldString696)); + } else { + charSequence696 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(696, charSequence696); + } else { + throw new RuntimeException(("Illegal union index for 'F696': "+ unionIndex696)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex697 = (decoder.readIndex()); + if (unionIndex697 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(697, null); + } else { + if (unionIndex697 == 1) { + Utf8 charSequence697; + Object oldString697 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(697); + if (oldString697 instanceof Utf8) { + charSequence697 = (decoder).readString(((Utf8) oldString697)); + } else { + charSequence697 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(697, charSequence697); + } else { + throw new RuntimeException(("Illegal union index for 'F697': "+ unionIndex697)); + } + } + int unionIndex698 = (decoder.readIndex()); + if (unionIndex698 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(698, null); + } else { + if (unionIndex698 == 1) { + Utf8 charSequence698; + Object oldString698 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(698); + if (oldString698 instanceof Utf8) { + charSequence698 = (decoder).readString(((Utf8) oldString698)); + } else { + charSequence698 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(698, charSequence698); + } else { + throw new RuntimeException(("Illegal union index for 'F698': "+ unionIndex698)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex699 = (decoder.readIndex()); + if (unionIndex699 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(699, null); + } else { + if (unionIndex699 == 1) { + Utf8 charSequence699; + Object oldString699 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(699); + if (oldString699 instanceof Utf8) { + charSequence699 = (decoder).readString(((Utf8) oldString699)); + } else { + charSequence699 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(699, charSequence699); + } else { + throw new RuntimeException(("Illegal union index for 'F699': "+ unionIndex699)); + } + } + int unionIndex700 = (decoder.readIndex()); + if (unionIndex700 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(700, null); + } else { + if (unionIndex700 == 1) { + Utf8 charSequence700; + Object oldString700 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(700); + if (oldString700 instanceof Utf8) { + charSequence700 = (decoder).readString(((Utf8) oldString700)); + } else { + charSequence700 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(700, charSequence700); + } else { + throw new RuntimeException(("Illegal union index for 'F700': "+ unionIndex700)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex701 = (decoder.readIndex()); + if (unionIndex701 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(701, null); + } else { + if (unionIndex701 == 1) { + Utf8 charSequence701; + Object oldString701 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(701); + if (oldString701 instanceof Utf8) { + charSequence701 = (decoder).readString(((Utf8) oldString701)); + } else { + charSequence701 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(701, charSequence701); + } else { + throw new RuntimeException(("Illegal union index for 'F701': "+ unionIndex701)); + } + } + int unionIndex702 = (decoder.readIndex()); + if (unionIndex702 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(702, null); + } else { + if (unionIndex702 == 1) { + Utf8 charSequence702; + Object oldString702 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(702); + if (oldString702 instanceof Utf8) { + charSequence702 = (decoder).readString(((Utf8) oldString702)); + } else { + charSequence702 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(702, charSequence702); + } else { + throw new RuntimeException(("Illegal union index for 'F702': "+ unionIndex702)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex703 = (decoder.readIndex()); + if (unionIndex703 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(703, null); + } else { + if (unionIndex703 == 1) { + Utf8 charSequence703; + Object oldString703 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(703); + if (oldString703 instanceof Utf8) { + charSequence703 = (decoder).readString(((Utf8) oldString703)); + } else { + charSequence703 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(703, charSequence703); + } else { + throw new RuntimeException(("Illegal union index for 'F703': "+ unionIndex703)); + } + } + int unionIndex704 = (decoder.readIndex()); + if (unionIndex704 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(704, null); + } else { + if (unionIndex704 == 1) { + Utf8 charSequence704; + Object oldString704 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(704); + if (oldString704 instanceof Utf8) { + charSequence704 = (decoder).readString(((Utf8) oldString704)); + } else { + charSequence704 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(704, charSequence704); + } else { + throw new RuntimeException(("Illegal union index for 'F704': "+ unionIndex704)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex705 = (decoder.readIndex()); + if (unionIndex705 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(705, null); + } else { + if (unionIndex705 == 1) { + Utf8 charSequence705; + Object oldString705 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(705); + if (oldString705 instanceof Utf8) { + charSequence705 = (decoder).readString(((Utf8) oldString705)); + } else { + charSequence705 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(705, charSequence705); + } else { + throw new RuntimeException(("Illegal union index for 'F705': "+ unionIndex705)); + } + } + int unionIndex706 = (decoder.readIndex()); + if (unionIndex706 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(706, null); + } else { + if (unionIndex706 == 1) { + Utf8 charSequence706; + Object oldString706 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(706); + if (oldString706 instanceof Utf8) { + charSequence706 = (decoder).readString(((Utf8) oldString706)); + } else { + charSequence706 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(706, charSequence706); + } else { + throw new RuntimeException(("Illegal union index for 'F706': "+ unionIndex706)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex707 = (decoder.readIndex()); + if (unionIndex707 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(707, null); + } else { + if (unionIndex707 == 1) { + Utf8 charSequence707; + Object oldString707 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(707); + if (oldString707 instanceof Utf8) { + charSequence707 = (decoder).readString(((Utf8) oldString707)); + } else { + charSequence707 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(707, charSequence707); + } else { + throw new RuntimeException(("Illegal union index for 'F707': "+ unionIndex707)); + } + } + int unionIndex708 = (decoder.readIndex()); + if (unionIndex708 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(708, null); + } else { + if (unionIndex708 == 1) { + Utf8 charSequence708; + Object oldString708 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(708); + if (oldString708 instanceof Utf8) { + charSequence708 = (decoder).readString(((Utf8) oldString708)); + } else { + charSequence708 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(708, charSequence708); + } else { + throw new RuntimeException(("Illegal union index for 'F708': "+ unionIndex708)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex709 = (decoder.readIndex()); + if (unionIndex709 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(709, null); + } else { + if (unionIndex709 == 1) { + Utf8 charSequence709; + Object oldString709 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(709); + if (oldString709 instanceof Utf8) { + charSequence709 = (decoder).readString(((Utf8) oldString709)); + } else { + charSequence709 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(709, charSequence709); + } else { + throw new RuntimeException(("Illegal union index for 'F709': "+ unionIndex709)); + } + } + int unionIndex710 = (decoder.readIndex()); + if (unionIndex710 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(710, null); + } else { + if (unionIndex710 == 1) { + Utf8 charSequence710; + Object oldString710 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(710); + if (oldString710 instanceof Utf8) { + charSequence710 = (decoder).readString(((Utf8) oldString710)); + } else { + charSequence710 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(710, charSequence710); + } else { + throw new RuntimeException(("Illegal union index for 'F710': "+ unionIndex710)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex711 = (decoder.readIndex()); + if (unionIndex711 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(711, null); + } else { + if (unionIndex711 == 1) { + Utf8 charSequence711; + Object oldString711 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(711); + if (oldString711 instanceof Utf8) { + charSequence711 = (decoder).readString(((Utf8) oldString711)); + } else { + charSequence711 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(711, charSequence711); + } else { + throw new RuntimeException(("Illegal union index for 'F711': "+ unionIndex711)); + } + } + int unionIndex712 = (decoder.readIndex()); + if (unionIndex712 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(712, null); + } else { + if (unionIndex712 == 1) { + Utf8 charSequence712; + Object oldString712 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(712); + if (oldString712 instanceof Utf8) { + charSequence712 = (decoder).readString(((Utf8) oldString712)); + } else { + charSequence712 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(712, charSequence712); + } else { + throw new RuntimeException(("Illegal union index for 'F712': "+ unionIndex712)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex713 = (decoder.readIndex()); + if (unionIndex713 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(713, null); + } else { + if (unionIndex713 == 1) { + Utf8 charSequence713; + Object oldString713 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(713); + if (oldString713 instanceof Utf8) { + charSequence713 = (decoder).readString(((Utf8) oldString713)); + } else { + charSequence713 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(713, charSequence713); + } else { + throw new RuntimeException(("Illegal union index for 'F713': "+ unionIndex713)); + } + } + int unionIndex714 = (decoder.readIndex()); + if (unionIndex714 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(714, null); + } else { + if (unionIndex714 == 1) { + Utf8 charSequence714; + Object oldString714 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(714); + if (oldString714 instanceof Utf8) { + charSequence714 = (decoder).readString(((Utf8) oldString714)); + } else { + charSequence714 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(714, charSequence714); + } else { + throw new RuntimeException(("Illegal union index for 'F714': "+ unionIndex714)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex715 = (decoder.readIndex()); + if (unionIndex715 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(715, null); + } else { + if (unionIndex715 == 1) { + Utf8 charSequence715; + Object oldString715 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(715); + if (oldString715 instanceof Utf8) { + charSequence715 = (decoder).readString(((Utf8) oldString715)); + } else { + charSequence715 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(715, charSequence715); + } else { + throw new RuntimeException(("Illegal union index for 'F715': "+ unionIndex715)); + } + } + int unionIndex716 = (decoder.readIndex()); + if (unionIndex716 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(716, null); + } else { + if (unionIndex716 == 1) { + Utf8 charSequence716; + Object oldString716 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(716); + if (oldString716 instanceof Utf8) { + charSequence716 = (decoder).readString(((Utf8) oldString716)); + } else { + charSequence716 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(716, charSequence716); + } else { + throw new RuntimeException(("Illegal union index for 'F716': "+ unionIndex716)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex717 = (decoder.readIndex()); + if (unionIndex717 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(717, null); + } else { + if (unionIndex717 == 1) { + Utf8 charSequence717; + Object oldString717 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(717); + if (oldString717 instanceof Utf8) { + charSequence717 = (decoder).readString(((Utf8) oldString717)); + } else { + charSequence717 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(717, charSequence717); + } else { + throw new RuntimeException(("Illegal union index for 'F717': "+ unionIndex717)); + } + } + int unionIndex718 = (decoder.readIndex()); + if (unionIndex718 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(718, null); + } else { + if (unionIndex718 == 1) { + Utf8 charSequence718; + Object oldString718 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(718); + if (oldString718 instanceof Utf8) { + charSequence718 = (decoder).readString(((Utf8) oldString718)); + } else { + charSequence718 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(718, charSequence718); + } else { + throw new RuntimeException(("Illegal union index for 'F718': "+ unionIndex718)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex719 = (decoder.readIndex()); + if (unionIndex719 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(719, null); + } else { + if (unionIndex719 == 1) { + Utf8 charSequence719; + Object oldString719 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(719); + if (oldString719 instanceof Utf8) { + charSequence719 = (decoder).readString(((Utf8) oldString719)); + } else { + charSequence719 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(719, charSequence719); + } else { + throw new RuntimeException(("Illegal union index for 'F719': "+ unionIndex719)); + } + } + int unionIndex720 = (decoder.readIndex()); + if (unionIndex720 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(720, null); + } else { + if (unionIndex720 == 1) { + Utf8 charSequence720; + Object oldString720 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(720); + if (oldString720 instanceof Utf8) { + charSequence720 = (decoder).readString(((Utf8) oldString720)); + } else { + charSequence720 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(720, charSequence720); + } else { + throw new RuntimeException(("Illegal union index for 'F720': "+ unionIndex720)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex721 = (decoder.readIndex()); + if (unionIndex721 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(721, null); + } else { + if (unionIndex721 == 1) { + Utf8 charSequence721; + Object oldString721 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(721); + if (oldString721 instanceof Utf8) { + charSequence721 = (decoder).readString(((Utf8) oldString721)); + } else { + charSequence721 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(721, charSequence721); + } else { + throw new RuntimeException(("Illegal union index for 'F721': "+ unionIndex721)); + } + } + int unionIndex722 = (decoder.readIndex()); + if (unionIndex722 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(722, null); + } else { + if (unionIndex722 == 1) { + Utf8 charSequence722; + Object oldString722 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(722); + if (oldString722 instanceof Utf8) { + charSequence722 = (decoder).readString(((Utf8) oldString722)); + } else { + charSequence722 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(722, charSequence722); + } else { + throw new RuntimeException(("Illegal union index for 'F722': "+ unionIndex722)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex723 = (decoder.readIndex()); + if (unionIndex723 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(723, null); + } else { + if (unionIndex723 == 1) { + Utf8 charSequence723; + Object oldString723 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(723); + if (oldString723 instanceof Utf8) { + charSequence723 = (decoder).readString(((Utf8) oldString723)); + } else { + charSequence723 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(723, charSequence723); + } else { + throw new RuntimeException(("Illegal union index for 'F723': "+ unionIndex723)); + } + } + int unionIndex724 = (decoder.readIndex()); + if (unionIndex724 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(724, null); + } else { + if (unionIndex724 == 1) { + Utf8 charSequence724; + Object oldString724 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(724); + if (oldString724 instanceof Utf8) { + charSequence724 = (decoder).readString(((Utf8) oldString724)); + } else { + charSequence724 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(724, charSequence724); + } else { + throw new RuntimeException(("Illegal union index for 'F724': "+ unionIndex724)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex725 = (decoder.readIndex()); + if (unionIndex725 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(725, null); + } else { + if (unionIndex725 == 1) { + Utf8 charSequence725; + Object oldString725 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(725); + if (oldString725 instanceof Utf8) { + charSequence725 = (decoder).readString(((Utf8) oldString725)); + } else { + charSequence725 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(725, charSequence725); + } else { + throw new RuntimeException(("Illegal union index for 'F725': "+ unionIndex725)); + } + } + int unionIndex726 = (decoder.readIndex()); + if (unionIndex726 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(726, null); + } else { + if (unionIndex726 == 1) { + Utf8 charSequence726; + Object oldString726 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(726); + if (oldString726 instanceof Utf8) { + charSequence726 = (decoder).readString(((Utf8) oldString726)); + } else { + charSequence726 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(726, charSequence726); + } else { + throw new RuntimeException(("Illegal union index for 'F726': "+ unionIndex726)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex727 = (decoder.readIndex()); + if (unionIndex727 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(727, null); + } else { + if (unionIndex727 == 1) { + Utf8 charSequence727; + Object oldString727 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(727); + if (oldString727 instanceof Utf8) { + charSequence727 = (decoder).readString(((Utf8) oldString727)); + } else { + charSequence727 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(727, charSequence727); + } else { + throw new RuntimeException(("Illegal union index for 'F727': "+ unionIndex727)); + } + } + int unionIndex728 = (decoder.readIndex()); + if (unionIndex728 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(728, null); + } else { + if (unionIndex728 == 1) { + Utf8 charSequence728; + Object oldString728 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(728); + if (oldString728 instanceof Utf8) { + charSequence728 = (decoder).readString(((Utf8) oldString728)); + } else { + charSequence728 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(728, charSequence728); + } else { + throw new RuntimeException(("Illegal union index for 'F728': "+ unionIndex728)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex729 = (decoder.readIndex()); + if (unionIndex729 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(729, null); + } else { + if (unionIndex729 == 1) { + Utf8 charSequence729; + Object oldString729 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(729); + if (oldString729 instanceof Utf8) { + charSequence729 = (decoder).readString(((Utf8) oldString729)); + } else { + charSequence729 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(729, charSequence729); + } else { + throw new RuntimeException(("Illegal union index for 'F729': "+ unionIndex729)); + } + } + int unionIndex730 = (decoder.readIndex()); + if (unionIndex730 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(730, null); + } else { + if (unionIndex730 == 1) { + Utf8 charSequence730; + Object oldString730 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(730); + if (oldString730 instanceof Utf8) { + charSequence730 = (decoder).readString(((Utf8) oldString730)); + } else { + charSequence730 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(730, charSequence730); + } else { + throw new RuntimeException(("Illegal union index for 'F730': "+ unionIndex730)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex731 = (decoder.readIndex()); + if (unionIndex731 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(731, null); + } else { + if (unionIndex731 == 1) { + Utf8 charSequence731; + Object oldString731 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(731); + if (oldString731 instanceof Utf8) { + charSequence731 = (decoder).readString(((Utf8) oldString731)); + } else { + charSequence731 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(731, charSequence731); + } else { + throw new RuntimeException(("Illegal union index for 'F731': "+ unionIndex731)); + } + } + int unionIndex732 = (decoder.readIndex()); + if (unionIndex732 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(732, null); + } else { + if (unionIndex732 == 1) { + Utf8 charSequence732; + Object oldString732 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(732); + if (oldString732 instanceof Utf8) { + charSequence732 = (decoder).readString(((Utf8) oldString732)); + } else { + charSequence732 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(732, charSequence732); + } else { + throw new RuntimeException(("Illegal union index for 'F732': "+ unionIndex732)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex733 = (decoder.readIndex()); + if (unionIndex733 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(733, null); + } else { + if (unionIndex733 == 1) { + Utf8 charSequence733; + Object oldString733 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(733); + if (oldString733 instanceof Utf8) { + charSequence733 = (decoder).readString(((Utf8) oldString733)); + } else { + charSequence733 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(733, charSequence733); + } else { + throw new RuntimeException(("Illegal union index for 'F733': "+ unionIndex733)); + } + } + int unionIndex734 = (decoder.readIndex()); + if (unionIndex734 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(734, null); + } else { + if (unionIndex734 == 1) { + Utf8 charSequence734; + Object oldString734 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(734); + if (oldString734 instanceof Utf8) { + charSequence734 = (decoder).readString(((Utf8) oldString734)); + } else { + charSequence734 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(734, charSequence734); + } else { + throw new RuntimeException(("Illegal union index for 'F734': "+ unionIndex734)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex735 = (decoder.readIndex()); + if (unionIndex735 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(735, null); + } else { + if (unionIndex735 == 1) { + Utf8 charSequence735; + Object oldString735 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(735); + if (oldString735 instanceof Utf8) { + charSequence735 = (decoder).readString(((Utf8) oldString735)); + } else { + charSequence735 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(735, charSequence735); + } else { + throw new RuntimeException(("Illegal union index for 'F735': "+ unionIndex735)); + } + } + int unionIndex736 = (decoder.readIndex()); + if (unionIndex736 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(736, null); + } else { + if (unionIndex736 == 1) { + Utf8 charSequence736; + Object oldString736 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(736); + if (oldString736 instanceof Utf8) { + charSequence736 = (decoder).readString(((Utf8) oldString736)); + } else { + charSequence736 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(736, charSequence736); + } else { + throw new RuntimeException(("Illegal union index for 'F736': "+ unionIndex736)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex737 = (decoder.readIndex()); + if (unionIndex737 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(737, null); + } else { + if (unionIndex737 == 1) { + Utf8 charSequence737; + Object oldString737 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(737); + if (oldString737 instanceof Utf8) { + charSequence737 = (decoder).readString(((Utf8) oldString737)); + } else { + charSequence737 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(737, charSequence737); + } else { + throw new RuntimeException(("Illegal union index for 'F737': "+ unionIndex737)); + } + } + int unionIndex738 = (decoder.readIndex()); + if (unionIndex738 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(738, null); + } else { + if (unionIndex738 == 1) { + Utf8 charSequence738; + Object oldString738 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(738); + if (oldString738 instanceof Utf8) { + charSequence738 = (decoder).readString(((Utf8) oldString738)); + } else { + charSequence738 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(738, charSequence738); + } else { + throw new RuntimeException(("Illegal union index for 'F738': "+ unionIndex738)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex739 = (decoder.readIndex()); + if (unionIndex739 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(739, null); + } else { + if (unionIndex739 == 1) { + Utf8 charSequence739; + Object oldString739 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(739); + if (oldString739 instanceof Utf8) { + charSequence739 = (decoder).readString(((Utf8) oldString739)); + } else { + charSequence739 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(739, charSequence739); + } else { + throw new RuntimeException(("Illegal union index for 'F739': "+ unionIndex739)); + } + } + int unionIndex740 = (decoder.readIndex()); + if (unionIndex740 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(740, null); + } else { + if (unionIndex740 == 1) { + Utf8 charSequence740; + Object oldString740 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(740); + if (oldString740 instanceof Utf8) { + charSequence740 = (decoder).readString(((Utf8) oldString740)); + } else { + charSequence740 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(740, charSequence740); + } else { + throw new RuntimeException(("Illegal union index for 'F740': "+ unionIndex740)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex741 = (decoder.readIndex()); + if (unionIndex741 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(741, null); + } else { + if (unionIndex741 == 1) { + Utf8 charSequence741; + Object oldString741 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(741); + if (oldString741 instanceof Utf8) { + charSequence741 = (decoder).readString(((Utf8) oldString741)); + } else { + charSequence741 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(741, charSequence741); + } else { + throw new RuntimeException(("Illegal union index for 'F741': "+ unionIndex741)); + } + } + int unionIndex742 = (decoder.readIndex()); + if (unionIndex742 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(742, null); + } else { + if (unionIndex742 == 1) { + Utf8 charSequence742; + Object oldString742 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(742); + if (oldString742 instanceof Utf8) { + charSequence742 = (decoder).readString(((Utf8) oldString742)); + } else { + charSequence742 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(742, charSequence742); + } else { + throw new RuntimeException(("Illegal union index for 'F742': "+ unionIndex742)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex743 = (decoder.readIndex()); + if (unionIndex743 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(743, null); + } else { + if (unionIndex743 == 1) { + Utf8 charSequence743; + Object oldString743 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(743); + if (oldString743 instanceof Utf8) { + charSequence743 = (decoder).readString(((Utf8) oldString743)); + } else { + charSequence743 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(743, charSequence743); + } else { + throw new RuntimeException(("Illegal union index for 'F743': "+ unionIndex743)); + } + } + int unionIndex744 = (decoder.readIndex()); + if (unionIndex744 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(744, null); + } else { + if (unionIndex744 == 1) { + Utf8 charSequence744; + Object oldString744 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(744); + if (oldString744 instanceof Utf8) { + charSequence744 = (decoder).readString(((Utf8) oldString744)); + } else { + charSequence744 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(744, charSequence744); + } else { + throw new RuntimeException(("Illegal union index for 'F744': "+ unionIndex744)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex745 = (decoder.readIndex()); + if (unionIndex745 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(745, null); + } else { + if (unionIndex745 == 1) { + Utf8 charSequence745; + Object oldString745 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(745); + if (oldString745 instanceof Utf8) { + charSequence745 = (decoder).readString(((Utf8) oldString745)); + } else { + charSequence745 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(745, charSequence745); + } else { + throw new RuntimeException(("Illegal union index for 'F745': "+ unionIndex745)); + } + } + int unionIndex746 = (decoder.readIndex()); + if (unionIndex746 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(746, null); + } else { + if (unionIndex746 == 1) { + Utf8 charSequence746; + Object oldString746 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(746); + if (oldString746 instanceof Utf8) { + charSequence746 = (decoder).readString(((Utf8) oldString746)); + } else { + charSequence746 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(746, charSequence746); + } else { + throw new RuntimeException(("Illegal union index for 'F746': "+ unionIndex746)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex747 = (decoder.readIndex()); + if (unionIndex747 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(747, null); + } else { + if (unionIndex747 == 1) { + Utf8 charSequence747; + Object oldString747 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(747); + if (oldString747 instanceof Utf8) { + charSequence747 = (decoder).readString(((Utf8) oldString747)); + } else { + charSequence747 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(747, charSequence747); + } else { + throw new RuntimeException(("Illegal union index for 'F747': "+ unionIndex747)); + } + } + int unionIndex748 = (decoder.readIndex()); + if (unionIndex748 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(748, null); + } else { + if (unionIndex748 == 1) { + Utf8 charSequence748; + Object oldString748 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(748); + if (oldString748 instanceof Utf8) { + charSequence748 = (decoder).readString(((Utf8) oldString748)); + } else { + charSequence748 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(748, charSequence748); + } else { + throw new RuntimeException(("Illegal union index for 'F748': "+ unionIndex748)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex749 = (decoder.readIndex()); + if (unionIndex749 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(749, null); + } else { + if (unionIndex749 == 1) { + Utf8 charSequence749; + Object oldString749 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(749); + if (oldString749 instanceof Utf8) { + charSequence749 = (decoder).readString(((Utf8) oldString749)); + } else { + charSequence749 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(749, charSequence749); + } else { + throw new RuntimeException(("Illegal union index for 'F749': "+ unionIndex749)); + } + } + int unionIndex750 = (decoder.readIndex()); + if (unionIndex750 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(750, null); + } else { + if (unionIndex750 == 1) { + Utf8 charSequence750; + Object oldString750 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(750); + if (oldString750 instanceof Utf8) { + charSequence750 = (decoder).readString(((Utf8) oldString750)); + } else { + charSequence750 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(750, charSequence750); + } else { + throw new RuntimeException(("Illegal union index for 'F750': "+ unionIndex750)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex751 = (decoder.readIndex()); + if (unionIndex751 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(751, null); + } else { + if (unionIndex751 == 1) { + Utf8 charSequence751; + Object oldString751 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(751); + if (oldString751 instanceof Utf8) { + charSequence751 = (decoder).readString(((Utf8) oldString751)); + } else { + charSequence751 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(751, charSequence751); + } else { + throw new RuntimeException(("Illegal union index for 'F751': "+ unionIndex751)); + } + } + int unionIndex752 = (decoder.readIndex()); + if (unionIndex752 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(752, null); + } else { + if (unionIndex752 == 1) { + Utf8 charSequence752; + Object oldString752 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(752); + if (oldString752 instanceof Utf8) { + charSequence752 = (decoder).readString(((Utf8) oldString752)); + } else { + charSequence752 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(752, charSequence752); + } else { + throw new RuntimeException(("Illegal union index for 'F752': "+ unionIndex752)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex753 = (decoder.readIndex()); + if (unionIndex753 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(753, null); + } else { + if (unionIndex753 == 1) { + Utf8 charSequence753; + Object oldString753 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(753); + if (oldString753 instanceof Utf8) { + charSequence753 = (decoder).readString(((Utf8) oldString753)); + } else { + charSequence753 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(753, charSequence753); + } else { + throw new RuntimeException(("Illegal union index for 'F753': "+ unionIndex753)); + } + } + int unionIndex754 = (decoder.readIndex()); + if (unionIndex754 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(754, null); + } else { + if (unionIndex754 == 1) { + Utf8 charSequence754; + Object oldString754 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(754); + if (oldString754 instanceof Utf8) { + charSequence754 = (decoder).readString(((Utf8) oldString754)); + } else { + charSequence754 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(754, charSequence754); + } else { + throw new RuntimeException(("Illegal union index for 'F754': "+ unionIndex754)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex755 = (decoder.readIndex()); + if (unionIndex755 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(755, null); + } else { + if (unionIndex755 == 1) { + Utf8 charSequence755; + Object oldString755 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(755); + if (oldString755 instanceof Utf8) { + charSequence755 = (decoder).readString(((Utf8) oldString755)); + } else { + charSequence755 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(755, charSequence755); + } else { + throw new RuntimeException(("Illegal union index for 'F755': "+ unionIndex755)); + } + } + int unionIndex756 = (decoder.readIndex()); + if (unionIndex756 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(756, null); + } else { + if (unionIndex756 == 1) { + Utf8 charSequence756; + Object oldString756 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(756); + if (oldString756 instanceof Utf8) { + charSequence756 = (decoder).readString(((Utf8) oldString756)); + } else { + charSequence756 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(756, charSequence756); + } else { + throw new RuntimeException(("Illegal union index for 'F756': "+ unionIndex756)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex757 = (decoder.readIndex()); + if (unionIndex757 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(757, null); + } else { + if (unionIndex757 == 1) { + Utf8 charSequence757; + Object oldString757 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(757); + if (oldString757 instanceof Utf8) { + charSequence757 = (decoder).readString(((Utf8) oldString757)); + } else { + charSequence757 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(757, charSequence757); + } else { + throw new RuntimeException(("Illegal union index for 'F757': "+ unionIndex757)); + } + } + int unionIndex758 = (decoder.readIndex()); + if (unionIndex758 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(758, null); + } else { + if (unionIndex758 == 1) { + Utf8 charSequence758; + Object oldString758 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(758); + if (oldString758 instanceof Utf8) { + charSequence758 = (decoder).readString(((Utf8) oldString758)); + } else { + charSequence758 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(758, charSequence758); + } else { + throw new RuntimeException(("Illegal union index for 'F758': "+ unionIndex758)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex759 = (decoder.readIndex()); + if (unionIndex759 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(759, null); + } else { + if (unionIndex759 == 1) { + Utf8 charSequence759; + Object oldString759 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(759); + if (oldString759 instanceof Utf8) { + charSequence759 = (decoder).readString(((Utf8) oldString759)); + } else { + charSequence759 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(759, charSequence759); + } else { + throw new RuntimeException(("Illegal union index for 'F759': "+ unionIndex759)); + } + } + int unionIndex760 = (decoder.readIndex()); + if (unionIndex760 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(760, null); + } else { + if (unionIndex760 == 1) { + Utf8 charSequence760; + Object oldString760 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(760); + if (oldString760 instanceof Utf8) { + charSequence760 = (decoder).readString(((Utf8) oldString760)); + } else { + charSequence760 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(760, charSequence760); + } else { + throw new RuntimeException(("Illegal union index for 'F760': "+ unionIndex760)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex761 = (decoder.readIndex()); + if (unionIndex761 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(761, null); + } else { + if (unionIndex761 == 1) { + Utf8 charSequence761; + Object oldString761 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(761); + if (oldString761 instanceof Utf8) { + charSequence761 = (decoder).readString(((Utf8) oldString761)); + } else { + charSequence761 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(761, charSequence761); + } else { + throw new RuntimeException(("Illegal union index for 'F761': "+ unionIndex761)); + } + } + int unionIndex762 = (decoder.readIndex()); + if (unionIndex762 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(762, null); + } else { + if (unionIndex762 == 1) { + Utf8 charSequence762; + Object oldString762 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(762); + if (oldString762 instanceof Utf8) { + charSequence762 = (decoder).readString(((Utf8) oldString762)); + } else { + charSequence762 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(762, charSequence762); + } else { + throw new RuntimeException(("Illegal union index for 'F762': "+ unionIndex762)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex763 = (decoder.readIndex()); + if (unionIndex763 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(763, null); + } else { + if (unionIndex763 == 1) { + Utf8 charSequence763; + Object oldString763 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(763); + if (oldString763 instanceof Utf8) { + charSequence763 = (decoder).readString(((Utf8) oldString763)); + } else { + charSequence763 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(763, charSequence763); + } else { + throw new RuntimeException(("Illegal union index for 'F763': "+ unionIndex763)); + } + } + int unionIndex764 = (decoder.readIndex()); + if (unionIndex764 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(764, null); + } else { + if (unionIndex764 == 1) { + Utf8 charSequence764; + Object oldString764 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(764); + if (oldString764 instanceof Utf8) { + charSequence764 = (decoder).readString(((Utf8) oldString764)); + } else { + charSequence764 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(764, charSequence764); + } else { + throw new RuntimeException(("Illegal union index for 'F764': "+ unionIndex764)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex765 = (decoder.readIndex()); + if (unionIndex765 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(765, null); + } else { + if (unionIndex765 == 1) { + Utf8 charSequence765; + Object oldString765 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(765); + if (oldString765 instanceof Utf8) { + charSequence765 = (decoder).readString(((Utf8) oldString765)); + } else { + charSequence765 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(765, charSequence765); + } else { + throw new RuntimeException(("Illegal union index for 'F765': "+ unionIndex765)); + } + } + int unionIndex766 = (decoder.readIndex()); + if (unionIndex766 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(766, null); + } else { + if (unionIndex766 == 1) { + Utf8 charSequence766; + Object oldString766 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(766); + if (oldString766 instanceof Utf8) { + charSequence766 = (decoder).readString(((Utf8) oldString766)); + } else { + charSequence766 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(766, charSequence766); + } else { + throw new RuntimeException(("Illegal union index for 'F766': "+ unionIndex766)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex767 = (decoder.readIndex()); + if (unionIndex767 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(767, null); + } else { + if (unionIndex767 == 1) { + Utf8 charSequence767; + Object oldString767 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(767); + if (oldString767 instanceof Utf8) { + charSequence767 = (decoder).readString(((Utf8) oldString767)); + } else { + charSequence767 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(767, charSequence767); + } else { + throw new RuntimeException(("Illegal union index for 'F767': "+ unionIndex767)); + } + } + int unionIndex768 = (decoder.readIndex()); + if (unionIndex768 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(768, null); + } else { + if (unionIndex768 == 1) { + Utf8 charSequence768; + Object oldString768 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(768); + if (oldString768 instanceof Utf8) { + charSequence768 = (decoder).readString(((Utf8) oldString768)); + } else { + charSequence768 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(768, charSequence768); + } else { + throw new RuntimeException(("Illegal union index for 'F768': "+ unionIndex768)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex769 = (decoder.readIndex()); + if (unionIndex769 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(769, null); + } else { + if (unionIndex769 == 1) { + Utf8 charSequence769; + Object oldString769 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(769); + if (oldString769 instanceof Utf8) { + charSequence769 = (decoder).readString(((Utf8) oldString769)); + } else { + charSequence769 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(769, charSequence769); + } else { + throw new RuntimeException(("Illegal union index for 'F769': "+ unionIndex769)); + } + } + int unionIndex770 = (decoder.readIndex()); + if (unionIndex770 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(770, null); + } else { + if (unionIndex770 == 1) { + Utf8 charSequence770; + Object oldString770 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(770); + if (oldString770 instanceof Utf8) { + charSequence770 = (decoder).readString(((Utf8) oldString770)); + } else { + charSequence770 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(770, charSequence770); + } else { + throw new RuntimeException(("Illegal union index for 'F770': "+ unionIndex770)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex771 = (decoder.readIndex()); + if (unionIndex771 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(771, null); + } else { + if (unionIndex771 == 1) { + Utf8 charSequence771; + Object oldString771 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(771); + if (oldString771 instanceof Utf8) { + charSequence771 = (decoder).readString(((Utf8) oldString771)); + } else { + charSequence771 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(771, charSequence771); + } else { + throw new RuntimeException(("Illegal union index for 'F771': "+ unionIndex771)); + } + } + int unionIndex772 = (decoder.readIndex()); + if (unionIndex772 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(772, null); + } else { + if (unionIndex772 == 1) { + Utf8 charSequence772; + Object oldString772 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(772); + if (oldString772 instanceof Utf8) { + charSequence772 = (decoder).readString(((Utf8) oldString772)); + } else { + charSequence772 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(772, charSequence772); + } else { + throw new RuntimeException(("Illegal union index for 'F772': "+ unionIndex772)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex773 = (decoder.readIndex()); + if (unionIndex773 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(773, null); + } else { + if (unionIndex773 == 1) { + Utf8 charSequence773; + Object oldString773 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(773); + if (oldString773 instanceof Utf8) { + charSequence773 = (decoder).readString(((Utf8) oldString773)); + } else { + charSequence773 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(773, charSequence773); + } else { + throw new RuntimeException(("Illegal union index for 'F773': "+ unionIndex773)); + } + } + int unionIndex774 = (decoder.readIndex()); + if (unionIndex774 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(774, null); + } else { + if (unionIndex774 == 1) { + Utf8 charSequence774; + Object oldString774 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(774); + if (oldString774 instanceof Utf8) { + charSequence774 = (decoder).readString(((Utf8) oldString774)); + } else { + charSequence774 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(774, charSequence774); + } else { + throw new RuntimeException(("Illegal union index for 'F774': "+ unionIndex774)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex775 = (decoder.readIndex()); + if (unionIndex775 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(775, null); + } else { + if (unionIndex775 == 1) { + Utf8 charSequence775; + Object oldString775 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(775); + if (oldString775 instanceof Utf8) { + charSequence775 = (decoder).readString(((Utf8) oldString775)); + } else { + charSequence775 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(775, charSequence775); + } else { + throw new RuntimeException(("Illegal union index for 'F775': "+ unionIndex775)); + } + } + int unionIndex776 = (decoder.readIndex()); + if (unionIndex776 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(776, null); + } else { + if (unionIndex776 == 1) { + Utf8 charSequence776; + Object oldString776 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(776); + if (oldString776 instanceof Utf8) { + charSequence776 = (decoder).readString(((Utf8) oldString776)); + } else { + charSequence776 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(776, charSequence776); + } else { + throw new RuntimeException(("Illegal union index for 'F776': "+ unionIndex776)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex777 = (decoder.readIndex()); + if (unionIndex777 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(777, null); + } else { + if (unionIndex777 == 1) { + Utf8 charSequence777; + Object oldString777 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(777); + if (oldString777 instanceof Utf8) { + charSequence777 = (decoder).readString(((Utf8) oldString777)); + } else { + charSequence777 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(777, charSequence777); + } else { + throw new RuntimeException(("Illegal union index for 'F777': "+ unionIndex777)); + } + } + int unionIndex778 = (decoder.readIndex()); + if (unionIndex778 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(778, null); + } else { + if (unionIndex778 == 1) { + Utf8 charSequence778; + Object oldString778 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(778); + if (oldString778 instanceof Utf8) { + charSequence778 = (decoder).readString(((Utf8) oldString778)); + } else { + charSequence778 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(778, charSequence778); + } else { + throw new RuntimeException(("Illegal union index for 'F778': "+ unionIndex778)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex779 = (decoder.readIndex()); + if (unionIndex779 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(779, null); + } else { + if (unionIndex779 == 1) { + Utf8 charSequence779; + Object oldString779 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(779); + if (oldString779 instanceof Utf8) { + charSequence779 = (decoder).readString(((Utf8) oldString779)); + } else { + charSequence779 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(779, charSequence779); + } else { + throw new RuntimeException(("Illegal union index for 'F779': "+ unionIndex779)); + } + } + int unionIndex780 = (decoder.readIndex()); + if (unionIndex780 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(780, null); + } else { + if (unionIndex780 == 1) { + Utf8 charSequence780; + Object oldString780 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(780); + if (oldString780 instanceof Utf8) { + charSequence780 = (decoder).readString(((Utf8) oldString780)); + } else { + charSequence780 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(780, charSequence780); + } else { + throw new RuntimeException(("Illegal union index for 'F780': "+ unionIndex780)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex781 = (decoder.readIndex()); + if (unionIndex781 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(781, null); + } else { + if (unionIndex781 == 1) { + Utf8 charSequence781; + Object oldString781 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(781); + if (oldString781 instanceof Utf8) { + charSequence781 = (decoder).readString(((Utf8) oldString781)); + } else { + charSequence781 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(781, charSequence781); + } else { + throw new RuntimeException(("Illegal union index for 'F781': "+ unionIndex781)); + } + } + int unionIndex782 = (decoder.readIndex()); + if (unionIndex782 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(782, null); + } else { + if (unionIndex782 == 1) { + Utf8 charSequence782; + Object oldString782 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(782); + if (oldString782 instanceof Utf8) { + charSequence782 = (decoder).readString(((Utf8) oldString782)); + } else { + charSequence782 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(782, charSequence782); + } else { + throw new RuntimeException(("Illegal union index for 'F782': "+ unionIndex782)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex783 = (decoder.readIndex()); + if (unionIndex783 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(783, null); + } else { + if (unionIndex783 == 1) { + Utf8 charSequence783; + Object oldString783 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(783); + if (oldString783 instanceof Utf8) { + charSequence783 = (decoder).readString(((Utf8) oldString783)); + } else { + charSequence783 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(783, charSequence783); + } else { + throw new RuntimeException(("Illegal union index for 'F783': "+ unionIndex783)); + } + } + int unionIndex784 = (decoder.readIndex()); + if (unionIndex784 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(784, null); + } else { + if (unionIndex784 == 1) { + Utf8 charSequence784; + Object oldString784 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(784); + if (oldString784 instanceof Utf8) { + charSequence784 = (decoder).readString(((Utf8) oldString784)); + } else { + charSequence784 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(784, charSequence784); + } else { + throw new RuntimeException(("Illegal union index for 'F784': "+ unionIndex784)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex785 = (decoder.readIndex()); + if (unionIndex785 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(785, null); + } else { + if (unionIndex785 == 1) { + Utf8 charSequence785; + Object oldString785 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(785); + if (oldString785 instanceof Utf8) { + charSequence785 = (decoder).readString(((Utf8) oldString785)); + } else { + charSequence785 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(785, charSequence785); + } else { + throw new RuntimeException(("Illegal union index for 'F785': "+ unionIndex785)); + } + } + int unionIndex786 = (decoder.readIndex()); + if (unionIndex786 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(786, null); + } else { + if (unionIndex786 == 1) { + Utf8 charSequence786; + Object oldString786 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(786); + if (oldString786 instanceof Utf8) { + charSequence786 = (decoder).readString(((Utf8) oldString786)); + } else { + charSequence786 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(786, charSequence786); + } else { + throw new RuntimeException(("Illegal union index for 'F786': "+ unionIndex786)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex787 = (decoder.readIndex()); + if (unionIndex787 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(787, null); + } else { + if (unionIndex787 == 1) { + Utf8 charSequence787; + Object oldString787 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(787); + if (oldString787 instanceof Utf8) { + charSequence787 = (decoder).readString(((Utf8) oldString787)); + } else { + charSequence787 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(787, charSequence787); + } else { + throw new RuntimeException(("Illegal union index for 'F787': "+ unionIndex787)); + } + } + int unionIndex788 = (decoder.readIndex()); + if (unionIndex788 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(788, null); + } else { + if (unionIndex788 == 1) { + Utf8 charSequence788; + Object oldString788 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(788); + if (oldString788 instanceof Utf8) { + charSequence788 = (decoder).readString(((Utf8) oldString788)); + } else { + charSequence788 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(788, charSequence788); + } else { + throw new RuntimeException(("Illegal union index for 'F788': "+ unionIndex788)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex789 = (decoder.readIndex()); + if (unionIndex789 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(789, null); + } else { + if (unionIndex789 == 1) { + Utf8 charSequence789; + Object oldString789 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(789); + if (oldString789 instanceof Utf8) { + charSequence789 = (decoder).readString(((Utf8) oldString789)); + } else { + charSequence789 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(789, charSequence789); + } else { + throw new RuntimeException(("Illegal union index for 'F789': "+ unionIndex789)); + } + } + int unionIndex790 = (decoder.readIndex()); + if (unionIndex790 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(790, null); + } else { + if (unionIndex790 == 1) { + Utf8 charSequence790; + Object oldString790 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(790); + if (oldString790 instanceof Utf8) { + charSequence790 = (decoder).readString(((Utf8) oldString790)); + } else { + charSequence790 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(790, charSequence790); + } else { + throw new RuntimeException(("Illegal union index for 'F790': "+ unionIndex790)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex791 = (decoder.readIndex()); + if (unionIndex791 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(791, null); + } else { + if (unionIndex791 == 1) { + Utf8 charSequence791; + Object oldString791 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(791); + if (oldString791 instanceof Utf8) { + charSequence791 = (decoder).readString(((Utf8) oldString791)); + } else { + charSequence791 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(791, charSequence791); + } else { + throw new RuntimeException(("Illegal union index for 'F791': "+ unionIndex791)); + } + } + int unionIndex792 = (decoder.readIndex()); + if (unionIndex792 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(792, null); + } else { + if (unionIndex792 == 1) { + Utf8 charSequence792; + Object oldString792 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(792); + if (oldString792 instanceof Utf8) { + charSequence792 = (decoder).readString(((Utf8) oldString792)); + } else { + charSequence792 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(792, charSequence792); + } else { + throw new RuntimeException(("Illegal union index for 'F792': "+ unionIndex792)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex793 = (decoder.readIndex()); + if (unionIndex793 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(793, null); + } else { + if (unionIndex793 == 1) { + Utf8 charSequence793; + Object oldString793 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(793); + if (oldString793 instanceof Utf8) { + charSequence793 = (decoder).readString(((Utf8) oldString793)); + } else { + charSequence793 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(793, charSequence793); + } else { + throw new RuntimeException(("Illegal union index for 'F793': "+ unionIndex793)); + } + } + int unionIndex794 = (decoder.readIndex()); + if (unionIndex794 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(794, null); + } else { + if (unionIndex794 == 1) { + Utf8 charSequence794; + Object oldString794 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(794); + if (oldString794 instanceof Utf8) { + charSequence794 = (decoder).readString(((Utf8) oldString794)); + } else { + charSequence794 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(794, charSequence794); + } else { + throw new RuntimeException(("Illegal union index for 'F794': "+ unionIndex794)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex795 = (decoder.readIndex()); + if (unionIndex795 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(795, null); + } else { + if (unionIndex795 == 1) { + Utf8 charSequence795; + Object oldString795 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(795); + if (oldString795 instanceof Utf8) { + charSequence795 = (decoder).readString(((Utf8) oldString795)); + } else { + charSequence795 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(795, charSequence795); + } else { + throw new RuntimeException(("Illegal union index for 'F795': "+ unionIndex795)); + } + } + int unionIndex796 = (decoder.readIndex()); + if (unionIndex796 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(796, null); + } else { + if (unionIndex796 == 1) { + Utf8 charSequence796; + Object oldString796 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(796); + if (oldString796 instanceof Utf8) { + charSequence796 = (decoder).readString(((Utf8) oldString796)); + } else { + charSequence796 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(796, charSequence796); + } else { + throw new RuntimeException(("Illegal union index for 'F796': "+ unionIndex796)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex797 = (decoder.readIndex()); + if (unionIndex797 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(797, null); + } else { + if (unionIndex797 == 1) { + Utf8 charSequence797; + Object oldString797 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(797); + if (oldString797 instanceof Utf8) { + charSequence797 = (decoder).readString(((Utf8) oldString797)); + } else { + charSequence797 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(797, charSequence797); + } else { + throw new RuntimeException(("Illegal union index for 'F797': "+ unionIndex797)); + } + } + int unionIndex798 = (decoder.readIndex()); + if (unionIndex798 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(798, null); + } else { + if (unionIndex798 == 1) { + Utf8 charSequence798; + Object oldString798 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(798); + if (oldString798 instanceof Utf8) { + charSequence798 = (decoder).readString(((Utf8) oldString798)); + } else { + charSequence798 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(798, charSequence798); + } else { + throw new RuntimeException(("Illegal union index for 'F798': "+ unionIndex798)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex799 = (decoder.readIndex()); + if (unionIndex799 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(799, null); + } else { + if (unionIndex799 == 1) { + Utf8 charSequence799; + Object oldString799 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(799); + if (oldString799 instanceof Utf8) { + charSequence799 = (decoder).readString(((Utf8) oldString799)); + } else { + charSequence799 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(799, charSequence799); + } else { + throw new RuntimeException(("Illegal union index for 'F799': "+ unionIndex799)); + } + } + int unionIndex800 = (decoder.readIndex()); + if (unionIndex800 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(800, null); + } else { + if (unionIndex800 == 1) { + Utf8 charSequence800; + Object oldString800 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(800); + if (oldString800 instanceof Utf8) { + charSequence800 = (decoder).readString(((Utf8) oldString800)); + } else { + charSequence800 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(800, charSequence800); + } else { + throw new RuntimeException(("Illegal union index for 'F800': "+ unionIndex800)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex801 = (decoder.readIndex()); + if (unionIndex801 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(801, null); + } else { + if (unionIndex801 == 1) { + Utf8 charSequence801; + Object oldString801 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(801); + if (oldString801 instanceof Utf8) { + charSequence801 = (decoder).readString(((Utf8) oldString801)); + } else { + charSequence801 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(801, charSequence801); + } else { + throw new RuntimeException(("Illegal union index for 'F801': "+ unionIndex801)); + } + } + int unionIndex802 = (decoder.readIndex()); + if (unionIndex802 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(802, null); + } else { + if (unionIndex802 == 1) { + Utf8 charSequence802; + Object oldString802 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(802); + if (oldString802 instanceof Utf8) { + charSequence802 = (decoder).readString(((Utf8) oldString802)); + } else { + charSequence802 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(802, charSequence802); + } else { + throw new RuntimeException(("Illegal union index for 'F802': "+ unionIndex802)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex803 = (decoder.readIndex()); + if (unionIndex803 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(803, null); + } else { + if (unionIndex803 == 1) { + Utf8 charSequence803; + Object oldString803 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(803); + if (oldString803 instanceof Utf8) { + charSequence803 = (decoder).readString(((Utf8) oldString803)); + } else { + charSequence803 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(803, charSequence803); + } else { + throw new RuntimeException(("Illegal union index for 'F803': "+ unionIndex803)); + } + } + int unionIndex804 = (decoder.readIndex()); + if (unionIndex804 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(804, null); + } else { + if (unionIndex804 == 1) { + Utf8 charSequence804; + Object oldString804 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(804); + if (oldString804 instanceof Utf8) { + charSequence804 = (decoder).readString(((Utf8) oldString804)); + } else { + charSequence804 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(804, charSequence804); + } else { + throw new RuntimeException(("Illegal union index for 'F804': "+ unionIndex804)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex805 = (decoder.readIndex()); + if (unionIndex805 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(805, null); + } else { + if (unionIndex805 == 1) { + Utf8 charSequence805; + Object oldString805 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(805); + if (oldString805 instanceof Utf8) { + charSequence805 = (decoder).readString(((Utf8) oldString805)); + } else { + charSequence805 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(805, charSequence805); + } else { + throw new RuntimeException(("Illegal union index for 'F805': "+ unionIndex805)); + } + } + int unionIndex806 = (decoder.readIndex()); + if (unionIndex806 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(806, null); + } else { + if (unionIndex806 == 1) { + Utf8 charSequence806; + Object oldString806 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(806); + if (oldString806 instanceof Utf8) { + charSequence806 = (decoder).readString(((Utf8) oldString806)); + } else { + charSequence806 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(806, charSequence806); + } else { + throw new RuntimeException(("Illegal union index for 'F806': "+ unionIndex806)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex807 = (decoder.readIndex()); + if (unionIndex807 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(807, null); + } else { + if (unionIndex807 == 1) { + Utf8 charSequence807; + Object oldString807 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(807); + if (oldString807 instanceof Utf8) { + charSequence807 = (decoder).readString(((Utf8) oldString807)); + } else { + charSequence807 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(807, charSequence807); + } else { + throw new RuntimeException(("Illegal union index for 'F807': "+ unionIndex807)); + } + } + int unionIndex808 = (decoder.readIndex()); + if (unionIndex808 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(808, null); + } else { + if (unionIndex808 == 1) { + Utf8 charSequence808; + Object oldString808 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(808); + if (oldString808 instanceof Utf8) { + charSequence808 = (decoder).readString(((Utf8) oldString808)); + } else { + charSequence808 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(808, charSequence808); + } else { + throw new RuntimeException(("Illegal union index for 'F808': "+ unionIndex808)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex809 = (decoder.readIndex()); + if (unionIndex809 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(809, null); + } else { + if (unionIndex809 == 1) { + Utf8 charSequence809; + Object oldString809 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(809); + if (oldString809 instanceof Utf8) { + charSequence809 = (decoder).readString(((Utf8) oldString809)); + } else { + charSequence809 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(809, charSequence809); + } else { + throw new RuntimeException(("Illegal union index for 'F809': "+ unionIndex809)); + } + } + int unionIndex810 = (decoder.readIndex()); + if (unionIndex810 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(810, null); + } else { + if (unionIndex810 == 1) { + Utf8 charSequence810; + Object oldString810 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(810); + if (oldString810 instanceof Utf8) { + charSequence810 = (decoder).readString(((Utf8) oldString810)); + } else { + charSequence810 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(810, charSequence810); + } else { + throw new RuntimeException(("Illegal union index for 'F810': "+ unionIndex810)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex811 = (decoder.readIndex()); + if (unionIndex811 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(811, null); + } else { + if (unionIndex811 == 1) { + Utf8 charSequence811; + Object oldString811 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(811); + if (oldString811 instanceof Utf8) { + charSequence811 = (decoder).readString(((Utf8) oldString811)); + } else { + charSequence811 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(811, charSequence811); + } else { + throw new RuntimeException(("Illegal union index for 'F811': "+ unionIndex811)); + } + } + int unionIndex812 = (decoder.readIndex()); + if (unionIndex812 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(812, null); + } else { + if (unionIndex812 == 1) { + Utf8 charSequence812; + Object oldString812 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(812); + if (oldString812 instanceof Utf8) { + charSequence812 = (decoder).readString(((Utf8) oldString812)); + } else { + charSequence812 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(812, charSequence812); + } else { + throw new RuntimeException(("Illegal union index for 'F812': "+ unionIndex812)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex813 = (decoder.readIndex()); + if (unionIndex813 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(813, null); + } else { + if (unionIndex813 == 1) { + Utf8 charSequence813; + Object oldString813 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(813); + if (oldString813 instanceof Utf8) { + charSequence813 = (decoder).readString(((Utf8) oldString813)); + } else { + charSequence813 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(813, charSequence813); + } else { + throw new RuntimeException(("Illegal union index for 'F813': "+ unionIndex813)); + } + } + int unionIndex814 = (decoder.readIndex()); + if (unionIndex814 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(814, null); + } else { + if (unionIndex814 == 1) { + Utf8 charSequence814; + Object oldString814 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(814); + if (oldString814 instanceof Utf8) { + charSequence814 = (decoder).readString(((Utf8) oldString814)); + } else { + charSequence814 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(814, charSequence814); + } else { + throw new RuntimeException(("Illegal union index for 'F814': "+ unionIndex814)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex815 = (decoder.readIndex()); + if (unionIndex815 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(815, null); + } else { + if (unionIndex815 == 1) { + Utf8 charSequence815; + Object oldString815 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(815); + if (oldString815 instanceof Utf8) { + charSequence815 = (decoder).readString(((Utf8) oldString815)); + } else { + charSequence815 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(815, charSequence815); + } else { + throw new RuntimeException(("Illegal union index for 'F815': "+ unionIndex815)); + } + } + int unionIndex816 = (decoder.readIndex()); + if (unionIndex816 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(816, null); + } else { + if (unionIndex816 == 1) { + Utf8 charSequence816; + Object oldString816 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(816); + if (oldString816 instanceof Utf8) { + charSequence816 = (decoder).readString(((Utf8) oldString816)); + } else { + charSequence816 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(816, charSequence816); + } else { + throw new RuntimeException(("Illegal union index for 'F816': "+ unionIndex816)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex817 = (decoder.readIndex()); + if (unionIndex817 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(817, null); + } else { + if (unionIndex817 == 1) { + Utf8 charSequence817; + Object oldString817 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(817); + if (oldString817 instanceof Utf8) { + charSequence817 = (decoder).readString(((Utf8) oldString817)); + } else { + charSequence817 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(817, charSequence817); + } else { + throw new RuntimeException(("Illegal union index for 'F817': "+ unionIndex817)); + } + } + int unionIndex818 = (decoder.readIndex()); + if (unionIndex818 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(818, null); + } else { + if (unionIndex818 == 1) { + Utf8 charSequence818; + Object oldString818 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(818); + if (oldString818 instanceof Utf8) { + charSequence818 = (decoder).readString(((Utf8) oldString818)); + } else { + charSequence818 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(818, charSequence818); + } else { + throw new RuntimeException(("Illegal union index for 'F818': "+ unionIndex818)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex819 = (decoder.readIndex()); + if (unionIndex819 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(819, null); + } else { + if (unionIndex819 == 1) { + Utf8 charSequence819; + Object oldString819 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(819); + if (oldString819 instanceof Utf8) { + charSequence819 = (decoder).readString(((Utf8) oldString819)); + } else { + charSequence819 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(819, charSequence819); + } else { + throw new RuntimeException(("Illegal union index for 'F819': "+ unionIndex819)); + } + } + int unionIndex820 = (decoder.readIndex()); + if (unionIndex820 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(820, null); + } else { + if (unionIndex820 == 1) { + Utf8 charSequence820; + Object oldString820 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(820); + if (oldString820 instanceof Utf8) { + charSequence820 = (decoder).readString(((Utf8) oldString820)); + } else { + charSequence820 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(820, charSequence820); + } else { + throw new RuntimeException(("Illegal union index for 'F820': "+ unionIndex820)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex821 = (decoder.readIndex()); + if (unionIndex821 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(821, null); + } else { + if (unionIndex821 == 1) { + Utf8 charSequence821; + Object oldString821 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(821); + if (oldString821 instanceof Utf8) { + charSequence821 = (decoder).readString(((Utf8) oldString821)); + } else { + charSequence821 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(821, charSequence821); + } else { + throw new RuntimeException(("Illegal union index for 'F821': "+ unionIndex821)); + } + } + int unionIndex822 = (decoder.readIndex()); + if (unionIndex822 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(822, null); + } else { + if (unionIndex822 == 1) { + Utf8 charSequence822; + Object oldString822 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(822); + if (oldString822 instanceof Utf8) { + charSequence822 = (decoder).readString(((Utf8) oldString822)); + } else { + charSequence822 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(822, charSequence822); + } else { + throw new RuntimeException(("Illegal union index for 'F822': "+ unionIndex822)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex823 = (decoder.readIndex()); + if (unionIndex823 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(823, null); + } else { + if (unionIndex823 == 1) { + Utf8 charSequence823; + Object oldString823 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(823); + if (oldString823 instanceof Utf8) { + charSequence823 = (decoder).readString(((Utf8) oldString823)); + } else { + charSequence823 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(823, charSequence823); + } else { + throw new RuntimeException(("Illegal union index for 'F823': "+ unionIndex823)); + } + } + int unionIndex824 = (decoder.readIndex()); + if (unionIndex824 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(824, null); + } else { + if (unionIndex824 == 1) { + Utf8 charSequence824; + Object oldString824 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(824); + if (oldString824 instanceof Utf8) { + charSequence824 = (decoder).readString(((Utf8) oldString824)); + } else { + charSequence824 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(824, charSequence824); + } else { + throw new RuntimeException(("Illegal union index for 'F824': "+ unionIndex824)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex825 = (decoder.readIndex()); + if (unionIndex825 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(825, null); + } else { + if (unionIndex825 == 1) { + Utf8 charSequence825; + Object oldString825 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(825); + if (oldString825 instanceof Utf8) { + charSequence825 = (decoder).readString(((Utf8) oldString825)); + } else { + charSequence825 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(825, charSequence825); + } else { + throw new RuntimeException(("Illegal union index for 'F825': "+ unionIndex825)); + } + } + int unionIndex826 = (decoder.readIndex()); + if (unionIndex826 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(826, null); + } else { + if (unionIndex826 == 1) { + Utf8 charSequence826; + Object oldString826 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(826); + if (oldString826 instanceof Utf8) { + charSequence826 = (decoder).readString(((Utf8) oldString826)); + } else { + charSequence826 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(826, charSequence826); + } else { + throw new RuntimeException(("Illegal union index for 'F826': "+ unionIndex826)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex827 = (decoder.readIndex()); + if (unionIndex827 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(827, null); + } else { + if (unionIndex827 == 1) { + Utf8 charSequence827; + Object oldString827 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(827); + if (oldString827 instanceof Utf8) { + charSequence827 = (decoder).readString(((Utf8) oldString827)); + } else { + charSequence827 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(827, charSequence827); + } else { + throw new RuntimeException(("Illegal union index for 'F827': "+ unionIndex827)); + } + } + int unionIndex828 = (decoder.readIndex()); + if (unionIndex828 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(828, null); + } else { + if (unionIndex828 == 1) { + Utf8 charSequence828; + Object oldString828 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(828); + if (oldString828 instanceof Utf8) { + charSequence828 = (decoder).readString(((Utf8) oldString828)); + } else { + charSequence828 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(828, charSequence828); + } else { + throw new RuntimeException(("Illegal union index for 'F828': "+ unionIndex828)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex829 = (decoder.readIndex()); + if (unionIndex829 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(829, null); + } else { + if (unionIndex829 == 1) { + Utf8 charSequence829; + Object oldString829 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(829); + if (oldString829 instanceof Utf8) { + charSequence829 = (decoder).readString(((Utf8) oldString829)); + } else { + charSequence829 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(829, charSequence829); + } else { + throw new RuntimeException(("Illegal union index for 'F829': "+ unionIndex829)); + } + } + int unionIndex830 = (decoder.readIndex()); + if (unionIndex830 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(830, null); + } else { + if (unionIndex830 == 1) { + Utf8 charSequence830; + Object oldString830 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(830); + if (oldString830 instanceof Utf8) { + charSequence830 = (decoder).readString(((Utf8) oldString830)); + } else { + charSequence830 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(830, charSequence830); + } else { + throw new RuntimeException(("Illegal union index for 'F830': "+ unionIndex830)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex831 = (decoder.readIndex()); + if (unionIndex831 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(831, null); + } else { + if (unionIndex831 == 1) { + Utf8 charSequence831; + Object oldString831 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(831); + if (oldString831 instanceof Utf8) { + charSequence831 = (decoder).readString(((Utf8) oldString831)); + } else { + charSequence831 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(831, charSequence831); + } else { + throw new RuntimeException(("Illegal union index for 'F831': "+ unionIndex831)); + } + } + int unionIndex832 = (decoder.readIndex()); + if (unionIndex832 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(832, null); + } else { + if (unionIndex832 == 1) { + Utf8 charSequence832; + Object oldString832 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(832); + if (oldString832 instanceof Utf8) { + charSequence832 = (decoder).readString(((Utf8) oldString832)); + } else { + charSequence832 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(832, charSequence832); + } else { + throw new RuntimeException(("Illegal union index for 'F832': "+ unionIndex832)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex833 = (decoder.readIndex()); + if (unionIndex833 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(833, null); + } else { + if (unionIndex833 == 1) { + Utf8 charSequence833; + Object oldString833 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(833); + if (oldString833 instanceof Utf8) { + charSequence833 = (decoder).readString(((Utf8) oldString833)); + } else { + charSequence833 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(833, charSequence833); + } else { + throw new RuntimeException(("Illegal union index for 'F833': "+ unionIndex833)); + } + } + int unionIndex834 = (decoder.readIndex()); + if (unionIndex834 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(834, null); + } else { + if (unionIndex834 == 1) { + Utf8 charSequence834; + Object oldString834 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(834); + if (oldString834 instanceof Utf8) { + charSequence834 = (decoder).readString(((Utf8) oldString834)); + } else { + charSequence834 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(834, charSequence834); + } else { + throw new RuntimeException(("Illegal union index for 'F834': "+ unionIndex834)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex835 = (decoder.readIndex()); + if (unionIndex835 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(835, null); + } else { + if (unionIndex835 == 1) { + Utf8 charSequence835; + Object oldString835 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(835); + if (oldString835 instanceof Utf8) { + charSequence835 = (decoder).readString(((Utf8) oldString835)); + } else { + charSequence835 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(835, charSequence835); + } else { + throw new RuntimeException(("Illegal union index for 'F835': "+ unionIndex835)); + } + } + int unionIndex836 = (decoder.readIndex()); + if (unionIndex836 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(836, null); + } else { + if (unionIndex836 == 1) { + Utf8 charSequence836; + Object oldString836 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(836); + if (oldString836 instanceof Utf8) { + charSequence836 = (decoder).readString(((Utf8) oldString836)); + } else { + charSequence836 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(836, charSequence836); + } else { + throw new RuntimeException(("Illegal union index for 'F836': "+ unionIndex836)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex837 = (decoder.readIndex()); + if (unionIndex837 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(837, null); + } else { + if (unionIndex837 == 1) { + Utf8 charSequence837; + Object oldString837 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(837); + if (oldString837 instanceof Utf8) { + charSequence837 = (decoder).readString(((Utf8) oldString837)); + } else { + charSequence837 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(837, charSequence837); + } else { + throw new RuntimeException(("Illegal union index for 'F837': "+ unionIndex837)); + } + } + int unionIndex838 = (decoder.readIndex()); + if (unionIndex838 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(838, null); + } else { + if (unionIndex838 == 1) { + Utf8 charSequence838; + Object oldString838 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(838); + if (oldString838 instanceof Utf8) { + charSequence838 = (decoder).readString(((Utf8) oldString838)); + } else { + charSequence838 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(838, charSequence838); + } else { + throw new RuntimeException(("Illegal union index for 'F838': "+ unionIndex838)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex839 = (decoder.readIndex()); + if (unionIndex839 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(839, null); + } else { + if (unionIndex839 == 1) { + Utf8 charSequence839; + Object oldString839 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(839); + if (oldString839 instanceof Utf8) { + charSequence839 = (decoder).readString(((Utf8) oldString839)); + } else { + charSequence839 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(839, charSequence839); + } else { + throw new RuntimeException(("Illegal union index for 'F839': "+ unionIndex839)); + } + } + int unionIndex840 = (decoder.readIndex()); + if (unionIndex840 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(840, null); + } else { + if (unionIndex840 == 1) { + Utf8 charSequence840; + Object oldString840 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(840); + if (oldString840 instanceof Utf8) { + charSequence840 = (decoder).readString(((Utf8) oldString840)); + } else { + charSequence840 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(840, charSequence840); + } else { + throw new RuntimeException(("Illegal union index for 'F840': "+ unionIndex840)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex841 = (decoder.readIndex()); + if (unionIndex841 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(841, null); + } else { + if (unionIndex841 == 1) { + Utf8 charSequence841; + Object oldString841 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(841); + if (oldString841 instanceof Utf8) { + charSequence841 = (decoder).readString(((Utf8) oldString841)); + } else { + charSequence841 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(841, charSequence841); + } else { + throw new RuntimeException(("Illegal union index for 'F841': "+ unionIndex841)); + } + } + int unionIndex842 = (decoder.readIndex()); + if (unionIndex842 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(842, null); + } else { + if (unionIndex842 == 1) { + Utf8 charSequence842; + Object oldString842 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(842); + if (oldString842 instanceof Utf8) { + charSequence842 = (decoder).readString(((Utf8) oldString842)); + } else { + charSequence842 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(842, charSequence842); + } else { + throw new RuntimeException(("Illegal union index for 'F842': "+ unionIndex842)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex843 = (decoder.readIndex()); + if (unionIndex843 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(843, null); + } else { + if (unionIndex843 == 1) { + Utf8 charSequence843; + Object oldString843 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(843); + if (oldString843 instanceof Utf8) { + charSequence843 = (decoder).readString(((Utf8) oldString843)); + } else { + charSequence843 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(843, charSequence843); + } else { + throw new RuntimeException(("Illegal union index for 'F843': "+ unionIndex843)); + } + } + int unionIndex844 = (decoder.readIndex()); + if (unionIndex844 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(844, null); + } else { + if (unionIndex844 == 1) { + Utf8 charSequence844; + Object oldString844 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(844); + if (oldString844 instanceof Utf8) { + charSequence844 = (decoder).readString(((Utf8) oldString844)); + } else { + charSequence844 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(844, charSequence844); + } else { + throw new RuntimeException(("Illegal union index for 'F844': "+ unionIndex844)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex845 = (decoder.readIndex()); + if (unionIndex845 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(845, null); + } else { + if (unionIndex845 == 1) { + Utf8 charSequence845; + Object oldString845 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(845); + if (oldString845 instanceof Utf8) { + charSequence845 = (decoder).readString(((Utf8) oldString845)); + } else { + charSequence845 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(845, charSequence845); + } else { + throw new RuntimeException(("Illegal union index for 'F845': "+ unionIndex845)); + } + } + int unionIndex846 = (decoder.readIndex()); + if (unionIndex846 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(846, null); + } else { + if (unionIndex846 == 1) { + Utf8 charSequence846; + Object oldString846 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(846); + if (oldString846 instanceof Utf8) { + charSequence846 = (decoder).readString(((Utf8) oldString846)); + } else { + charSequence846 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(846, charSequence846); + } else { + throw new RuntimeException(("Illegal union index for 'F846': "+ unionIndex846)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex847 = (decoder.readIndex()); + if (unionIndex847 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(847, null); + } else { + if (unionIndex847 == 1) { + Utf8 charSequence847; + Object oldString847 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(847); + if (oldString847 instanceof Utf8) { + charSequence847 = (decoder).readString(((Utf8) oldString847)); + } else { + charSequence847 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(847, charSequence847); + } else { + throw new RuntimeException(("Illegal union index for 'F847': "+ unionIndex847)); + } + } + int unionIndex848 = (decoder.readIndex()); + if (unionIndex848 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(848, null); + } else { + if (unionIndex848 == 1) { + Utf8 charSequence848; + Object oldString848 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(848); + if (oldString848 instanceof Utf8) { + charSequence848 = (decoder).readString(((Utf8) oldString848)); + } else { + charSequence848 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(848, charSequence848); + } else { + throw new RuntimeException(("Illegal union index for 'F848': "+ unionIndex848)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex849 = (decoder.readIndex()); + if (unionIndex849 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(849, null); + } else { + if (unionIndex849 == 1) { + Utf8 charSequence849; + Object oldString849 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(849); + if (oldString849 instanceof Utf8) { + charSequence849 = (decoder).readString(((Utf8) oldString849)); + } else { + charSequence849 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(849, charSequence849); + } else { + throw new RuntimeException(("Illegal union index for 'F849': "+ unionIndex849)); + } + } + int unionIndex850 = (decoder.readIndex()); + if (unionIndex850 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(850, null); + } else { + if (unionIndex850 == 1) { + Utf8 charSequence850; + Object oldString850 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(850); + if (oldString850 instanceof Utf8) { + charSequence850 = (decoder).readString(((Utf8) oldString850)); + } else { + charSequence850 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(850, charSequence850); + } else { + throw new RuntimeException(("Illegal union index for 'F850': "+ unionIndex850)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex851 = (decoder.readIndex()); + if (unionIndex851 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(851, null); + } else { + if (unionIndex851 == 1) { + Utf8 charSequence851; + Object oldString851 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(851); + if (oldString851 instanceof Utf8) { + charSequence851 = (decoder).readString(((Utf8) oldString851)); + } else { + charSequence851 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(851, charSequence851); + } else { + throw new RuntimeException(("Illegal union index for 'F851': "+ unionIndex851)); + } + } + int unionIndex852 = (decoder.readIndex()); + if (unionIndex852 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(852, null); + } else { + if (unionIndex852 == 1) { + Utf8 charSequence852; + Object oldString852 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(852); + if (oldString852 instanceof Utf8) { + charSequence852 = (decoder).readString(((Utf8) oldString852)); + } else { + charSequence852 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(852, charSequence852); + } else { + throw new RuntimeException(("Illegal union index for 'F852': "+ unionIndex852)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex853 = (decoder.readIndex()); + if (unionIndex853 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(853, null); + } else { + if (unionIndex853 == 1) { + Utf8 charSequence853; + Object oldString853 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(853); + if (oldString853 instanceof Utf8) { + charSequence853 = (decoder).readString(((Utf8) oldString853)); + } else { + charSequence853 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(853, charSequence853); + } else { + throw new RuntimeException(("Illegal union index for 'F853': "+ unionIndex853)); + } + } + int unionIndex854 = (decoder.readIndex()); + if (unionIndex854 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(854, null); + } else { + if (unionIndex854 == 1) { + Utf8 charSequence854; + Object oldString854 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(854); + if (oldString854 instanceof Utf8) { + charSequence854 = (decoder).readString(((Utf8) oldString854)); + } else { + charSequence854 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(854, charSequence854); + } else { + throw new RuntimeException(("Illegal union index for 'F854': "+ unionIndex854)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex855 = (decoder.readIndex()); + if (unionIndex855 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(855, null); + } else { + if (unionIndex855 == 1) { + Utf8 charSequence855; + Object oldString855 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(855); + if (oldString855 instanceof Utf8) { + charSequence855 = (decoder).readString(((Utf8) oldString855)); + } else { + charSequence855 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(855, charSequence855); + } else { + throw new RuntimeException(("Illegal union index for 'F855': "+ unionIndex855)); + } + } + int unionIndex856 = (decoder.readIndex()); + if (unionIndex856 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(856, null); + } else { + if (unionIndex856 == 1) { + Utf8 charSequence856; + Object oldString856 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(856); + if (oldString856 instanceof Utf8) { + charSequence856 = (decoder).readString(((Utf8) oldString856)); + } else { + charSequence856 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(856, charSequence856); + } else { + throw new RuntimeException(("Illegal union index for 'F856': "+ unionIndex856)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex857 = (decoder.readIndex()); + if (unionIndex857 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(857, null); + } else { + if (unionIndex857 == 1) { + Utf8 charSequence857; + Object oldString857 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(857); + if (oldString857 instanceof Utf8) { + charSequence857 = (decoder).readString(((Utf8) oldString857)); + } else { + charSequence857 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(857, charSequence857); + } else { + throw new RuntimeException(("Illegal union index for 'F857': "+ unionIndex857)); + } + } + int unionIndex858 = (decoder.readIndex()); + if (unionIndex858 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(858, null); + } else { + if (unionIndex858 == 1) { + Utf8 charSequence858; + Object oldString858 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(858); + if (oldString858 instanceof Utf8) { + charSequence858 = (decoder).readString(((Utf8) oldString858)); + } else { + charSequence858 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(858, charSequence858); + } else { + throw new RuntimeException(("Illegal union index for 'F858': "+ unionIndex858)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex859 = (decoder.readIndex()); + if (unionIndex859 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(859, null); + } else { + if (unionIndex859 == 1) { + Utf8 charSequence859; + Object oldString859 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(859); + if (oldString859 instanceof Utf8) { + charSequence859 = (decoder).readString(((Utf8) oldString859)); + } else { + charSequence859 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(859, charSequence859); + } else { + throw new RuntimeException(("Illegal union index for 'F859': "+ unionIndex859)); + } + } + int unionIndex860 = (decoder.readIndex()); + if (unionIndex860 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(860, null); + } else { + if (unionIndex860 == 1) { + Utf8 charSequence860; + Object oldString860 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(860); + if (oldString860 instanceof Utf8) { + charSequence860 = (decoder).readString(((Utf8) oldString860)); + } else { + charSequence860 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(860, charSequence860); + } else { + throw new RuntimeException(("Illegal union index for 'F860': "+ unionIndex860)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex861 = (decoder.readIndex()); + if (unionIndex861 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(861, null); + } else { + if (unionIndex861 == 1) { + Utf8 charSequence861; + Object oldString861 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(861); + if (oldString861 instanceof Utf8) { + charSequence861 = (decoder).readString(((Utf8) oldString861)); + } else { + charSequence861 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(861, charSequence861); + } else { + throw new RuntimeException(("Illegal union index for 'F861': "+ unionIndex861)); + } + } + int unionIndex862 = (decoder.readIndex()); + if (unionIndex862 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(862, null); + } else { + if (unionIndex862 == 1) { + Utf8 charSequence862; + Object oldString862 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(862); + if (oldString862 instanceof Utf8) { + charSequence862 = (decoder).readString(((Utf8) oldString862)); + } else { + charSequence862 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(862, charSequence862); + } else { + throw new RuntimeException(("Illegal union index for 'F862': "+ unionIndex862)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex863 = (decoder.readIndex()); + if (unionIndex863 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(863, null); + } else { + if (unionIndex863 == 1) { + Utf8 charSequence863; + Object oldString863 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(863); + if (oldString863 instanceof Utf8) { + charSequence863 = (decoder).readString(((Utf8) oldString863)); + } else { + charSequence863 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(863, charSequence863); + } else { + throw new RuntimeException(("Illegal union index for 'F863': "+ unionIndex863)); + } + } + int unionIndex864 = (decoder.readIndex()); + if (unionIndex864 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(864, null); + } else { + if (unionIndex864 == 1) { + Utf8 charSequence864; + Object oldString864 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(864); + if (oldString864 instanceof Utf8) { + charSequence864 = (decoder).readString(((Utf8) oldString864)); + } else { + charSequence864 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(864, charSequence864); + } else { + throw new RuntimeException(("Illegal union index for 'F864': "+ unionIndex864)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex865 = (decoder.readIndex()); + if (unionIndex865 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(865, null); + } else { + if (unionIndex865 == 1) { + Utf8 charSequence865; + Object oldString865 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(865); + if (oldString865 instanceof Utf8) { + charSequence865 = (decoder).readString(((Utf8) oldString865)); + } else { + charSequence865 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(865, charSequence865); + } else { + throw new RuntimeException(("Illegal union index for 'F865': "+ unionIndex865)); + } + } + int unionIndex866 = (decoder.readIndex()); + if (unionIndex866 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(866, null); + } else { + if (unionIndex866 == 1) { + Utf8 charSequence866; + Object oldString866 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(866); + if (oldString866 instanceof Utf8) { + charSequence866 = (decoder).readString(((Utf8) oldString866)); + } else { + charSequence866 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(866, charSequence866); + } else { + throw new RuntimeException(("Illegal union index for 'F866': "+ unionIndex866)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex867 = (decoder.readIndex()); + if (unionIndex867 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(867, null); + } else { + if (unionIndex867 == 1) { + Utf8 charSequence867; + Object oldString867 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(867); + if (oldString867 instanceof Utf8) { + charSequence867 = (decoder).readString(((Utf8) oldString867)); + } else { + charSequence867 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(867, charSequence867); + } else { + throw new RuntimeException(("Illegal union index for 'F867': "+ unionIndex867)); + } + } + int unionIndex868 = (decoder.readIndex()); + if (unionIndex868 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(868, null); + } else { + if (unionIndex868 == 1) { + Utf8 charSequence868; + Object oldString868 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(868); + if (oldString868 instanceof Utf8) { + charSequence868 = (decoder).readString(((Utf8) oldString868)); + } else { + charSequence868 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(868, charSequence868); + } else { + throw new RuntimeException(("Illegal union index for 'F868': "+ unionIndex868)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex869 = (decoder.readIndex()); + if (unionIndex869 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(869, null); + } else { + if (unionIndex869 == 1) { + Utf8 charSequence869; + Object oldString869 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(869); + if (oldString869 instanceof Utf8) { + charSequence869 = (decoder).readString(((Utf8) oldString869)); + } else { + charSequence869 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(869, charSequence869); + } else { + throw new RuntimeException(("Illegal union index for 'F869': "+ unionIndex869)); + } + } + int unionIndex870 = (decoder.readIndex()); + if (unionIndex870 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(870, null); + } else { + if (unionIndex870 == 1) { + Utf8 charSequence870; + Object oldString870 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(870); + if (oldString870 instanceof Utf8) { + charSequence870 = (decoder).readString(((Utf8) oldString870)); + } else { + charSequence870 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(870, charSequence870); + } else { + throw new RuntimeException(("Illegal union index for 'F870': "+ unionIndex870)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex871 = (decoder.readIndex()); + if (unionIndex871 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(871, null); + } else { + if (unionIndex871 == 1) { + Utf8 charSequence871; + Object oldString871 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(871); + if (oldString871 instanceof Utf8) { + charSequence871 = (decoder).readString(((Utf8) oldString871)); + } else { + charSequence871 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(871, charSequence871); + } else { + throw new RuntimeException(("Illegal union index for 'F871': "+ unionIndex871)); + } + } + int unionIndex872 = (decoder.readIndex()); + if (unionIndex872 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(872, null); + } else { + if (unionIndex872 == 1) { + Utf8 charSequence872; + Object oldString872 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(872); + if (oldString872 instanceof Utf8) { + charSequence872 = (decoder).readString(((Utf8) oldString872)); + } else { + charSequence872 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(872, charSequence872); + } else { + throw new RuntimeException(("Illegal union index for 'F872': "+ unionIndex872)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex873 = (decoder.readIndex()); + if (unionIndex873 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(873, null); + } else { + if (unionIndex873 == 1) { + Utf8 charSequence873; + Object oldString873 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(873); + if (oldString873 instanceof Utf8) { + charSequence873 = (decoder).readString(((Utf8) oldString873)); + } else { + charSequence873 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(873, charSequence873); + } else { + throw new RuntimeException(("Illegal union index for 'F873': "+ unionIndex873)); + } + } + int unionIndex874 = (decoder.readIndex()); + if (unionIndex874 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(874, null); + } else { + if (unionIndex874 == 1) { + Utf8 charSequence874; + Object oldString874 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(874); + if (oldString874 instanceof Utf8) { + charSequence874 = (decoder).readString(((Utf8) oldString874)); + } else { + charSequence874 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(874, charSequence874); + } else { + throw new RuntimeException(("Illegal union index for 'F874': "+ unionIndex874)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex875 = (decoder.readIndex()); + if (unionIndex875 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(875, null); + } else { + if (unionIndex875 == 1) { + Utf8 charSequence875; + Object oldString875 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(875); + if (oldString875 instanceof Utf8) { + charSequence875 = (decoder).readString(((Utf8) oldString875)); + } else { + charSequence875 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(875, charSequence875); + } else { + throw new RuntimeException(("Illegal union index for 'F875': "+ unionIndex875)); + } + } + int unionIndex876 = (decoder.readIndex()); + if (unionIndex876 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(876, null); + } else { + if (unionIndex876 == 1) { + Utf8 charSequence876; + Object oldString876 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(876); + if (oldString876 instanceof Utf8) { + charSequence876 = (decoder).readString(((Utf8) oldString876)); + } else { + charSequence876 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(876, charSequence876); + } else { + throw new RuntimeException(("Illegal union index for 'F876': "+ unionIndex876)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex877 = (decoder.readIndex()); + if (unionIndex877 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(877, null); + } else { + if (unionIndex877 == 1) { + Utf8 charSequence877; + Object oldString877 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(877); + if (oldString877 instanceof Utf8) { + charSequence877 = (decoder).readString(((Utf8) oldString877)); + } else { + charSequence877 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(877, charSequence877); + } else { + throw new RuntimeException(("Illegal union index for 'F877': "+ unionIndex877)); + } + } + int unionIndex878 = (decoder.readIndex()); + if (unionIndex878 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(878, null); + } else { + if (unionIndex878 == 1) { + Utf8 charSequence878; + Object oldString878 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(878); + if (oldString878 instanceof Utf8) { + charSequence878 = (decoder).readString(((Utf8) oldString878)); + } else { + charSequence878 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(878, charSequence878); + } else { + throw new RuntimeException(("Illegal union index for 'F878': "+ unionIndex878)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex879 = (decoder.readIndex()); + if (unionIndex879 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(879, null); + } else { + if (unionIndex879 == 1) { + Utf8 charSequence879; + Object oldString879 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(879); + if (oldString879 instanceof Utf8) { + charSequence879 = (decoder).readString(((Utf8) oldString879)); + } else { + charSequence879 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(879, charSequence879); + } else { + throw new RuntimeException(("Illegal union index for 'F879': "+ unionIndex879)); + } + } + int unionIndex880 = (decoder.readIndex()); + if (unionIndex880 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(880, null); + } else { + if (unionIndex880 == 1) { + Utf8 charSequence880; + Object oldString880 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(880); + if (oldString880 instanceof Utf8) { + charSequence880 = (decoder).readString(((Utf8) oldString880)); + } else { + charSequence880 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(880, charSequence880); + } else { + throw new RuntimeException(("Illegal union index for 'F880': "+ unionIndex880)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex881 = (decoder.readIndex()); + if (unionIndex881 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(881, null); + } else { + if (unionIndex881 == 1) { + Utf8 charSequence881; + Object oldString881 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(881); + if (oldString881 instanceof Utf8) { + charSequence881 = (decoder).readString(((Utf8) oldString881)); + } else { + charSequence881 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(881, charSequence881); + } else { + throw new RuntimeException(("Illegal union index for 'F881': "+ unionIndex881)); + } + } + int unionIndex882 = (decoder.readIndex()); + if (unionIndex882 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(882, null); + } else { + if (unionIndex882 == 1) { + Utf8 charSequence882; + Object oldString882 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(882); + if (oldString882 instanceof Utf8) { + charSequence882 = (decoder).readString(((Utf8) oldString882)); + } else { + charSequence882 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(882, charSequence882); + } else { + throw new RuntimeException(("Illegal union index for 'F882': "+ unionIndex882)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex883 = (decoder.readIndex()); + if (unionIndex883 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(883, null); + } else { + if (unionIndex883 == 1) { + Utf8 charSequence883; + Object oldString883 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(883); + if (oldString883 instanceof Utf8) { + charSequence883 = (decoder).readString(((Utf8) oldString883)); + } else { + charSequence883 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(883, charSequence883); + } else { + throw new RuntimeException(("Illegal union index for 'F883': "+ unionIndex883)); + } + } + int unionIndex884 = (decoder.readIndex()); + if (unionIndex884 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(884, null); + } else { + if (unionIndex884 == 1) { + Utf8 charSequence884; + Object oldString884 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(884); + if (oldString884 instanceof Utf8) { + charSequence884 = (decoder).readString(((Utf8) oldString884)); + } else { + charSequence884 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(884, charSequence884); + } else { + throw new RuntimeException(("Illegal union index for 'F884': "+ unionIndex884)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex885 = (decoder.readIndex()); + if (unionIndex885 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(885, null); + } else { + if (unionIndex885 == 1) { + Utf8 charSequence885; + Object oldString885 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(885); + if (oldString885 instanceof Utf8) { + charSequence885 = (decoder).readString(((Utf8) oldString885)); + } else { + charSequence885 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(885, charSequence885); + } else { + throw new RuntimeException(("Illegal union index for 'F885': "+ unionIndex885)); + } + } + int unionIndex886 = (decoder.readIndex()); + if (unionIndex886 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(886, null); + } else { + if (unionIndex886 == 1) { + Utf8 charSequence886; + Object oldString886 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(886); + if (oldString886 instanceof Utf8) { + charSequence886 = (decoder).readString(((Utf8) oldString886)); + } else { + charSequence886 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(886, charSequence886); + } else { + throw new RuntimeException(("Illegal union index for 'F886': "+ unionIndex886)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex887 = (decoder.readIndex()); + if (unionIndex887 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(887, null); + } else { + if (unionIndex887 == 1) { + Utf8 charSequence887; + Object oldString887 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(887); + if (oldString887 instanceof Utf8) { + charSequence887 = (decoder).readString(((Utf8) oldString887)); + } else { + charSequence887 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(887, charSequence887); + } else { + throw new RuntimeException(("Illegal union index for 'F887': "+ unionIndex887)); + } + } + int unionIndex888 = (decoder.readIndex()); + if (unionIndex888 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(888, null); + } else { + if (unionIndex888 == 1) { + Utf8 charSequence888; + Object oldString888 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(888); + if (oldString888 instanceof Utf8) { + charSequence888 = (decoder).readString(((Utf8) oldString888)); + } else { + charSequence888 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(888, charSequence888); + } else { + throw new RuntimeException(("Illegal union index for 'F888': "+ unionIndex888)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex889 = (decoder.readIndex()); + if (unionIndex889 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(889, null); + } else { + if (unionIndex889 == 1) { + Utf8 charSequence889; + Object oldString889 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(889); + if (oldString889 instanceof Utf8) { + charSequence889 = (decoder).readString(((Utf8) oldString889)); + } else { + charSequence889 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(889, charSequence889); + } else { + throw new RuntimeException(("Illegal union index for 'F889': "+ unionIndex889)); + } + } + int unionIndex890 = (decoder.readIndex()); + if (unionIndex890 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(890, null); + } else { + if (unionIndex890 == 1) { + Utf8 charSequence890; + Object oldString890 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(890); + if (oldString890 instanceof Utf8) { + charSequence890 = (decoder).readString(((Utf8) oldString890)); + } else { + charSequence890 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(890, charSequence890); + } else { + throw new RuntimeException(("Illegal union index for 'F890': "+ unionIndex890)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex891 = (decoder.readIndex()); + if (unionIndex891 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(891, null); + } else { + if (unionIndex891 == 1) { + Utf8 charSequence891; + Object oldString891 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(891); + if (oldString891 instanceof Utf8) { + charSequence891 = (decoder).readString(((Utf8) oldString891)); + } else { + charSequence891 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(891, charSequence891); + } else { + throw new RuntimeException(("Illegal union index for 'F891': "+ unionIndex891)); + } + } + int unionIndex892 = (decoder.readIndex()); + if (unionIndex892 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(892, null); + } else { + if (unionIndex892 == 1) { + Utf8 charSequence892; + Object oldString892 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(892); + if (oldString892 instanceof Utf8) { + charSequence892 = (decoder).readString(((Utf8) oldString892)); + } else { + charSequence892 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(892, charSequence892); + } else { + throw new RuntimeException(("Illegal union index for 'F892': "+ unionIndex892)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex893 = (decoder.readIndex()); + if (unionIndex893 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(893, null); + } else { + if (unionIndex893 == 1) { + Utf8 charSequence893; + Object oldString893 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(893); + if (oldString893 instanceof Utf8) { + charSequence893 = (decoder).readString(((Utf8) oldString893)); + } else { + charSequence893 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(893, charSequence893); + } else { + throw new RuntimeException(("Illegal union index for 'F893': "+ unionIndex893)); + } + } + int unionIndex894 = (decoder.readIndex()); + if (unionIndex894 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(894, null); + } else { + if (unionIndex894 == 1) { + Utf8 charSequence894; + Object oldString894 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(894); + if (oldString894 instanceof Utf8) { + charSequence894 = (decoder).readString(((Utf8) oldString894)); + } else { + charSequence894 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(894, charSequence894); + } else { + throw new RuntimeException(("Illegal union index for 'F894': "+ unionIndex894)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex895 = (decoder.readIndex()); + if (unionIndex895 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(895, null); + } else { + if (unionIndex895 == 1) { + Utf8 charSequence895; + Object oldString895 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(895); + if (oldString895 instanceof Utf8) { + charSequence895 = (decoder).readString(((Utf8) oldString895)); + } else { + charSequence895 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(895, charSequence895); + } else { + throw new RuntimeException(("Illegal union index for 'F895': "+ unionIndex895)); + } + } + int unionIndex896 = (decoder.readIndex()); + if (unionIndex896 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(896, null); + } else { + if (unionIndex896 == 1) { + Utf8 charSequence896; + Object oldString896 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(896); + if (oldString896 instanceof Utf8) { + charSequence896 = (decoder).readString(((Utf8) oldString896)); + } else { + charSequence896 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(896, charSequence896); + } else { + throw new RuntimeException(("Illegal union index for 'F896': "+ unionIndex896)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex897 = (decoder.readIndex()); + if (unionIndex897 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(897, null); + } else { + if (unionIndex897 == 1) { + Utf8 charSequence897; + Object oldString897 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(897); + if (oldString897 instanceof Utf8) { + charSequence897 = (decoder).readString(((Utf8) oldString897)); + } else { + charSequence897 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(897, charSequence897); + } else { + throw new RuntimeException(("Illegal union index for 'F897': "+ unionIndex897)); + } + } + int unionIndex898 = (decoder.readIndex()); + if (unionIndex898 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(898, null); + } else { + if (unionIndex898 == 1) { + Utf8 charSequence898; + Object oldString898 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(898); + if (oldString898 instanceof Utf8) { + charSequence898 = (decoder).readString(((Utf8) oldString898)); + } else { + charSequence898 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(898, charSequence898); + } else { + throw new RuntimeException(("Illegal union index for 'F898': "+ unionIndex898)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex899 = (decoder.readIndex()); + if (unionIndex899 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(899, null); + } else { + if (unionIndex899 == 1) { + Utf8 charSequence899; + Object oldString899 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(899); + if (oldString899 instanceof Utf8) { + charSequence899 = (decoder).readString(((Utf8) oldString899)); + } else { + charSequence899 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(899, charSequence899); + } else { + throw new RuntimeException(("Illegal union index for 'F899': "+ unionIndex899)); + } + } + int unionIndex900 = (decoder.readIndex()); + if (unionIndex900 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(900, null); + } else { + if (unionIndex900 == 1) { + Utf8 charSequence900; + Object oldString900 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(900); + if (oldString900 instanceof Utf8) { + charSequence900 = (decoder).readString(((Utf8) oldString900)); + } else { + charSequence900 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(900, charSequence900); + } else { + throw new RuntimeException(("Illegal union index for 'F900': "+ unionIndex900)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex901 = (decoder.readIndex()); + if (unionIndex901 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(901, null); + } else { + if (unionIndex901 == 1) { + Utf8 charSequence901; + Object oldString901 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(901); + if (oldString901 instanceof Utf8) { + charSequence901 = (decoder).readString(((Utf8) oldString901)); + } else { + charSequence901 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(901, charSequence901); + } else { + throw new RuntimeException(("Illegal union index for 'F901': "+ unionIndex901)); + } + } + int unionIndex902 = (decoder.readIndex()); + if (unionIndex902 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(902, null); + } else { + if (unionIndex902 == 1) { + Utf8 charSequence902; + Object oldString902 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(902); + if (oldString902 instanceof Utf8) { + charSequence902 = (decoder).readString(((Utf8) oldString902)); + } else { + charSequence902 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(902, charSequence902); + } else { + throw new RuntimeException(("Illegal union index for 'F902': "+ unionIndex902)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex903 = (decoder.readIndex()); + if (unionIndex903 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(903, null); + } else { + if (unionIndex903 == 1) { + Utf8 charSequence903; + Object oldString903 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(903); + if (oldString903 instanceof Utf8) { + charSequence903 = (decoder).readString(((Utf8) oldString903)); + } else { + charSequence903 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(903, charSequence903); + } else { + throw new RuntimeException(("Illegal union index for 'F903': "+ unionIndex903)); + } + } + int unionIndex904 = (decoder.readIndex()); + if (unionIndex904 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(904, null); + } else { + if (unionIndex904 == 1) { + Utf8 charSequence904; + Object oldString904 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(904); + if (oldString904 instanceof Utf8) { + charSequence904 = (decoder).readString(((Utf8) oldString904)); + } else { + charSequence904 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(904, charSequence904); + } else { + throw new RuntimeException(("Illegal union index for 'F904': "+ unionIndex904)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex905 = (decoder.readIndex()); + if (unionIndex905 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(905, null); + } else { + if (unionIndex905 == 1) { + Utf8 charSequence905; + Object oldString905 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(905); + if (oldString905 instanceof Utf8) { + charSequence905 = (decoder).readString(((Utf8) oldString905)); + } else { + charSequence905 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(905, charSequence905); + } else { + throw new RuntimeException(("Illegal union index for 'F905': "+ unionIndex905)); + } + } + int unionIndex906 = (decoder.readIndex()); + if (unionIndex906 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(906, null); + } else { + if (unionIndex906 == 1) { + Utf8 charSequence906; + Object oldString906 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(906); + if (oldString906 instanceof Utf8) { + charSequence906 = (decoder).readString(((Utf8) oldString906)); + } else { + charSequence906 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(906, charSequence906); + } else { + throw new RuntimeException(("Illegal union index for 'F906': "+ unionIndex906)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex907 = (decoder.readIndex()); + if (unionIndex907 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(907, null); + } else { + if (unionIndex907 == 1) { + Utf8 charSequence907; + Object oldString907 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(907); + if (oldString907 instanceof Utf8) { + charSequence907 = (decoder).readString(((Utf8) oldString907)); + } else { + charSequence907 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(907, charSequence907); + } else { + throw new RuntimeException(("Illegal union index for 'F907': "+ unionIndex907)); + } + } + int unionIndex908 = (decoder.readIndex()); + if (unionIndex908 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(908, null); + } else { + if (unionIndex908 == 1) { + Utf8 charSequence908; + Object oldString908 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(908); + if (oldString908 instanceof Utf8) { + charSequence908 = (decoder).readString(((Utf8) oldString908)); + } else { + charSequence908 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(908, charSequence908); + } else { + throw new RuntimeException(("Illegal union index for 'F908': "+ unionIndex908)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex909 = (decoder.readIndex()); + if (unionIndex909 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(909, null); + } else { + if (unionIndex909 == 1) { + Utf8 charSequence909; + Object oldString909 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(909); + if (oldString909 instanceof Utf8) { + charSequence909 = (decoder).readString(((Utf8) oldString909)); + } else { + charSequence909 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(909, charSequence909); + } else { + throw new RuntimeException(("Illegal union index for 'F909': "+ unionIndex909)); + } + } + int unionIndex910 = (decoder.readIndex()); + if (unionIndex910 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(910, null); + } else { + if (unionIndex910 == 1) { + Utf8 charSequence910; + Object oldString910 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(910); + if (oldString910 instanceof Utf8) { + charSequence910 = (decoder).readString(((Utf8) oldString910)); + } else { + charSequence910 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(910, charSequence910); + } else { + throw new RuntimeException(("Illegal union index for 'F910': "+ unionIndex910)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex911 = (decoder.readIndex()); + if (unionIndex911 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(911, null); + } else { + if (unionIndex911 == 1) { + Utf8 charSequence911; + Object oldString911 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(911); + if (oldString911 instanceof Utf8) { + charSequence911 = (decoder).readString(((Utf8) oldString911)); + } else { + charSequence911 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(911, charSequence911); + } else { + throw new RuntimeException(("Illegal union index for 'F911': "+ unionIndex911)); + } + } + int unionIndex912 = (decoder.readIndex()); + if (unionIndex912 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(912, null); + } else { + if (unionIndex912 == 1) { + Utf8 charSequence912; + Object oldString912 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(912); + if (oldString912 instanceof Utf8) { + charSequence912 = (decoder).readString(((Utf8) oldString912)); + } else { + charSequence912 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(912, charSequence912); + } else { + throw new RuntimeException(("Illegal union index for 'F912': "+ unionIndex912)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex913 = (decoder.readIndex()); + if (unionIndex913 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(913, null); + } else { + if (unionIndex913 == 1) { + Utf8 charSequence913; + Object oldString913 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(913); + if (oldString913 instanceof Utf8) { + charSequence913 = (decoder).readString(((Utf8) oldString913)); + } else { + charSequence913 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(913, charSequence913); + } else { + throw new RuntimeException(("Illegal union index for 'F913': "+ unionIndex913)); + } + } + int unionIndex914 = (decoder.readIndex()); + if (unionIndex914 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(914, null); + } else { + if (unionIndex914 == 1) { + Utf8 charSequence914; + Object oldString914 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(914); + if (oldString914 instanceof Utf8) { + charSequence914 = (decoder).readString(((Utf8) oldString914)); + } else { + charSequence914 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(914, charSequence914); + } else { + throw new RuntimeException(("Illegal union index for 'F914': "+ unionIndex914)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex915 = (decoder.readIndex()); + if (unionIndex915 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(915, null); + } else { + if (unionIndex915 == 1) { + Utf8 charSequence915; + Object oldString915 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(915); + if (oldString915 instanceof Utf8) { + charSequence915 = (decoder).readString(((Utf8) oldString915)); + } else { + charSequence915 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(915, charSequence915); + } else { + throw new RuntimeException(("Illegal union index for 'F915': "+ unionIndex915)); + } + } + int unionIndex916 = (decoder.readIndex()); + if (unionIndex916 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(916, null); + } else { + if (unionIndex916 == 1) { + Utf8 charSequence916; + Object oldString916 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(916); + if (oldString916 instanceof Utf8) { + charSequence916 = (decoder).readString(((Utf8) oldString916)); + } else { + charSequence916 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(916, charSequence916); + } else { + throw new RuntimeException(("Illegal union index for 'F916': "+ unionIndex916)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex917 = (decoder.readIndex()); + if (unionIndex917 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(917, null); + } else { + if (unionIndex917 == 1) { + Utf8 charSequence917; + Object oldString917 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(917); + if (oldString917 instanceof Utf8) { + charSequence917 = (decoder).readString(((Utf8) oldString917)); + } else { + charSequence917 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(917, charSequence917); + } else { + throw new RuntimeException(("Illegal union index for 'F917': "+ unionIndex917)); + } + } + int unionIndex918 = (decoder.readIndex()); + if (unionIndex918 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(918, null); + } else { + if (unionIndex918 == 1) { + Utf8 charSequence918; + Object oldString918 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(918); + if (oldString918 instanceof Utf8) { + charSequence918 = (decoder).readString(((Utf8) oldString918)); + } else { + charSequence918 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(918, charSequence918); + } else { + throw new RuntimeException(("Illegal union index for 'F918': "+ unionIndex918)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex919 = (decoder.readIndex()); + if (unionIndex919 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(919, null); + } else { + if (unionIndex919 == 1) { + Utf8 charSequence919; + Object oldString919 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(919); + if (oldString919 instanceof Utf8) { + charSequence919 = (decoder).readString(((Utf8) oldString919)); + } else { + charSequence919 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(919, charSequence919); + } else { + throw new RuntimeException(("Illegal union index for 'F919': "+ unionIndex919)); + } + } + int unionIndex920 = (decoder.readIndex()); + if (unionIndex920 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(920, null); + } else { + if (unionIndex920 == 1) { + Utf8 charSequence920; + Object oldString920 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(920); + if (oldString920 instanceof Utf8) { + charSequence920 = (decoder).readString(((Utf8) oldString920)); + } else { + charSequence920 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(920, charSequence920); + } else { + throw new RuntimeException(("Illegal union index for 'F920': "+ unionIndex920)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex921 = (decoder.readIndex()); + if (unionIndex921 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(921, null); + } else { + if (unionIndex921 == 1) { + Utf8 charSequence921; + Object oldString921 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(921); + if (oldString921 instanceof Utf8) { + charSequence921 = (decoder).readString(((Utf8) oldString921)); + } else { + charSequence921 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(921, charSequence921); + } else { + throw new RuntimeException(("Illegal union index for 'F921': "+ unionIndex921)); + } + } + int unionIndex922 = (decoder.readIndex()); + if (unionIndex922 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(922, null); + } else { + if (unionIndex922 == 1) { + Utf8 charSequence922; + Object oldString922 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(922); + if (oldString922 instanceof Utf8) { + charSequence922 = (decoder).readString(((Utf8) oldString922)); + } else { + charSequence922 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(922, charSequence922); + } else { + throw new RuntimeException(("Illegal union index for 'F922': "+ unionIndex922)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex923 = (decoder.readIndex()); + if (unionIndex923 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(923, null); + } else { + if (unionIndex923 == 1) { + Utf8 charSequence923; + Object oldString923 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(923); + if (oldString923 instanceof Utf8) { + charSequence923 = (decoder).readString(((Utf8) oldString923)); + } else { + charSequence923 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(923, charSequence923); + } else { + throw new RuntimeException(("Illegal union index for 'F923': "+ unionIndex923)); + } + } + int unionIndex924 = (decoder.readIndex()); + if (unionIndex924 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(924, null); + } else { + if (unionIndex924 == 1) { + Utf8 charSequence924; + Object oldString924 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(924); + if (oldString924 instanceof Utf8) { + charSequence924 = (decoder).readString(((Utf8) oldString924)); + } else { + charSequence924 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(924, charSequence924); + } else { + throw new RuntimeException(("Illegal union index for 'F924': "+ unionIndex924)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex925 = (decoder.readIndex()); + if (unionIndex925 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(925, null); + } else { + if (unionIndex925 == 1) { + Utf8 charSequence925; + Object oldString925 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(925); + if (oldString925 instanceof Utf8) { + charSequence925 = (decoder).readString(((Utf8) oldString925)); + } else { + charSequence925 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(925, charSequence925); + } else { + throw new RuntimeException(("Illegal union index for 'F925': "+ unionIndex925)); + } + } + int unionIndex926 = (decoder.readIndex()); + if (unionIndex926 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(926, null); + } else { + if (unionIndex926 == 1) { + Utf8 charSequence926; + Object oldString926 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(926); + if (oldString926 instanceof Utf8) { + charSequence926 = (decoder).readString(((Utf8) oldString926)); + } else { + charSequence926 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(926, charSequence926); + } else { + throw new RuntimeException(("Illegal union index for 'F926': "+ unionIndex926)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex927 = (decoder.readIndex()); + if (unionIndex927 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(927, null); + } else { + if (unionIndex927 == 1) { + Utf8 charSequence927; + Object oldString927 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(927); + if (oldString927 instanceof Utf8) { + charSequence927 = (decoder).readString(((Utf8) oldString927)); + } else { + charSequence927 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(927, charSequence927); + } else { + throw new RuntimeException(("Illegal union index for 'F927': "+ unionIndex927)); + } + } + int unionIndex928 = (decoder.readIndex()); + if (unionIndex928 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(928, null); + } else { + if (unionIndex928 == 1) { + Utf8 charSequence928; + Object oldString928 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(928); + if (oldString928 instanceof Utf8) { + charSequence928 = (decoder).readString(((Utf8) oldString928)); + } else { + charSequence928 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(928, charSequence928); + } else { + throw new RuntimeException(("Illegal union index for 'F928': "+ unionIndex928)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex929 = (decoder.readIndex()); + if (unionIndex929 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(929, null); + } else { + if (unionIndex929 == 1) { + Utf8 charSequence929; + Object oldString929 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(929); + if (oldString929 instanceof Utf8) { + charSequence929 = (decoder).readString(((Utf8) oldString929)); + } else { + charSequence929 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(929, charSequence929); + } else { + throw new RuntimeException(("Illegal union index for 'F929': "+ unionIndex929)); + } + } + int unionIndex930 = (decoder.readIndex()); + if (unionIndex930 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(930, null); + } else { + if (unionIndex930 == 1) { + Utf8 charSequence930; + Object oldString930 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(930); + if (oldString930 instanceof Utf8) { + charSequence930 = (decoder).readString(((Utf8) oldString930)); + } else { + charSequence930 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(930, charSequence930); + } else { + throw new RuntimeException(("Illegal union index for 'F930': "+ unionIndex930)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex931 = (decoder.readIndex()); + if (unionIndex931 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(931, null); + } else { + if (unionIndex931 == 1) { + Utf8 charSequence931; + Object oldString931 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(931); + if (oldString931 instanceof Utf8) { + charSequence931 = (decoder).readString(((Utf8) oldString931)); + } else { + charSequence931 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(931, charSequence931); + } else { + throw new RuntimeException(("Illegal union index for 'F931': "+ unionIndex931)); + } + } + int unionIndex932 = (decoder.readIndex()); + if (unionIndex932 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(932, null); + } else { + if (unionIndex932 == 1) { + Utf8 charSequence932; + Object oldString932 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(932); + if (oldString932 instanceof Utf8) { + charSequence932 = (decoder).readString(((Utf8) oldString932)); + } else { + charSequence932 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(932, charSequence932); + } else { + throw new RuntimeException(("Illegal union index for 'F932': "+ unionIndex932)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex933 = (decoder.readIndex()); + if (unionIndex933 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(933, null); + } else { + if (unionIndex933 == 1) { + Utf8 charSequence933; + Object oldString933 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(933); + if (oldString933 instanceof Utf8) { + charSequence933 = (decoder).readString(((Utf8) oldString933)); + } else { + charSequence933 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(933, charSequence933); + } else { + throw new RuntimeException(("Illegal union index for 'F933': "+ unionIndex933)); + } + } + int unionIndex934 = (decoder.readIndex()); + if (unionIndex934 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(934, null); + } else { + if (unionIndex934 == 1) { + Utf8 charSequence934; + Object oldString934 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(934); + if (oldString934 instanceof Utf8) { + charSequence934 = (decoder).readString(((Utf8) oldString934)); + } else { + charSequence934 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(934, charSequence934); + } else { + throw new RuntimeException(("Illegal union index for 'F934': "+ unionIndex934)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex935 = (decoder.readIndex()); + if (unionIndex935 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(935, null); + } else { + if (unionIndex935 == 1) { + Utf8 charSequence935; + Object oldString935 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(935); + if (oldString935 instanceof Utf8) { + charSequence935 = (decoder).readString(((Utf8) oldString935)); + } else { + charSequence935 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(935, charSequence935); + } else { + throw new RuntimeException(("Illegal union index for 'F935': "+ unionIndex935)); + } + } + int unionIndex936 = (decoder.readIndex()); + if (unionIndex936 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(936, null); + } else { + if (unionIndex936 == 1) { + Utf8 charSequence936; + Object oldString936 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(936); + if (oldString936 instanceof Utf8) { + charSequence936 = (decoder).readString(((Utf8) oldString936)); + } else { + charSequence936 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(936, charSequence936); + } else { + throw new RuntimeException(("Illegal union index for 'F936': "+ unionIndex936)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex937 = (decoder.readIndex()); + if (unionIndex937 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(937, null); + } else { + if (unionIndex937 == 1) { + Utf8 charSequence937; + Object oldString937 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(937); + if (oldString937 instanceof Utf8) { + charSequence937 = (decoder).readString(((Utf8) oldString937)); + } else { + charSequence937 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(937, charSequence937); + } else { + throw new RuntimeException(("Illegal union index for 'F937': "+ unionIndex937)); + } + } + int unionIndex938 = (decoder.readIndex()); + if (unionIndex938 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(938, null); + } else { + if (unionIndex938 == 1) { + Utf8 charSequence938; + Object oldString938 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(938); + if (oldString938 instanceof Utf8) { + charSequence938 = (decoder).readString(((Utf8) oldString938)); + } else { + charSequence938 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(938, charSequence938); + } else { + throw new RuntimeException(("Illegal union index for 'F938': "+ unionIndex938)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex939 = (decoder.readIndex()); + if (unionIndex939 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(939, null); + } else { + if (unionIndex939 == 1) { + Utf8 charSequence939; + Object oldString939 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(939); + if (oldString939 instanceof Utf8) { + charSequence939 = (decoder).readString(((Utf8) oldString939)); + } else { + charSequence939 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(939, charSequence939); + } else { + throw new RuntimeException(("Illegal union index for 'F939': "+ unionIndex939)); + } + } + int unionIndex940 = (decoder.readIndex()); + if (unionIndex940 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(940, null); + } else { + if (unionIndex940 == 1) { + Utf8 charSequence940; + Object oldString940 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(940); + if (oldString940 instanceof Utf8) { + charSequence940 = (decoder).readString(((Utf8) oldString940)); + } else { + charSequence940 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(940, charSequence940); + } else { + throw new RuntimeException(("Illegal union index for 'F940': "+ unionIndex940)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex941 = (decoder.readIndex()); + if (unionIndex941 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(941, null); + } else { + if (unionIndex941 == 1) { + Utf8 charSequence941; + Object oldString941 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(941); + if (oldString941 instanceof Utf8) { + charSequence941 = (decoder).readString(((Utf8) oldString941)); + } else { + charSequence941 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(941, charSequence941); + } else { + throw new RuntimeException(("Illegal union index for 'F941': "+ unionIndex941)); + } + } + int unionIndex942 = (decoder.readIndex()); + if (unionIndex942 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(942, null); + } else { + if (unionIndex942 == 1) { + Utf8 charSequence942; + Object oldString942 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(942); + if (oldString942 instanceof Utf8) { + charSequence942 = (decoder).readString(((Utf8) oldString942)); + } else { + charSequence942 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(942, charSequence942); + } else { + throw new RuntimeException(("Illegal union index for 'F942': "+ unionIndex942)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex943 = (decoder.readIndex()); + if (unionIndex943 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(943, null); + } else { + if (unionIndex943 == 1) { + Utf8 charSequence943; + Object oldString943 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(943); + if (oldString943 instanceof Utf8) { + charSequence943 = (decoder).readString(((Utf8) oldString943)); + } else { + charSequence943 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(943, charSequence943); + } else { + throw new RuntimeException(("Illegal union index for 'F943': "+ unionIndex943)); + } + } + int unionIndex944 = (decoder.readIndex()); + if (unionIndex944 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(944, null); + } else { + if (unionIndex944 == 1) { + Utf8 charSequence944; + Object oldString944 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(944); + if (oldString944 instanceof Utf8) { + charSequence944 = (decoder).readString(((Utf8) oldString944)); + } else { + charSequence944 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(944, charSequence944); + } else { + throw new RuntimeException(("Illegal union index for 'F944': "+ unionIndex944)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex945 = (decoder.readIndex()); + if (unionIndex945 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(945, null); + } else { + if (unionIndex945 == 1) { + Utf8 charSequence945; + Object oldString945 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(945); + if (oldString945 instanceof Utf8) { + charSequence945 = (decoder).readString(((Utf8) oldString945)); + } else { + charSequence945 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(945, charSequence945); + } else { + throw new RuntimeException(("Illegal union index for 'F945': "+ unionIndex945)); + } + } + int unionIndex946 = (decoder.readIndex()); + if (unionIndex946 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(946, null); + } else { + if (unionIndex946 == 1) { + Utf8 charSequence946; + Object oldString946 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(946); + if (oldString946 instanceof Utf8) { + charSequence946 = (decoder).readString(((Utf8) oldString946)); + } else { + charSequence946 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(946, charSequence946); + } else { + throw new RuntimeException(("Illegal union index for 'F946': "+ unionIndex946)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex947 = (decoder.readIndex()); + if (unionIndex947 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(947, null); + } else { + if (unionIndex947 == 1) { + Utf8 charSequence947; + Object oldString947 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(947); + if (oldString947 instanceof Utf8) { + charSequence947 = (decoder).readString(((Utf8) oldString947)); + } else { + charSequence947 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(947, charSequence947); + } else { + throw new RuntimeException(("Illegal union index for 'F947': "+ unionIndex947)); + } + } + int unionIndex948 = (decoder.readIndex()); + if (unionIndex948 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(948, null); + } else { + if (unionIndex948 == 1) { + Utf8 charSequence948; + Object oldString948 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(948); + if (oldString948 instanceof Utf8) { + charSequence948 = (decoder).readString(((Utf8) oldString948)); + } else { + charSequence948 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(948, charSequence948); + } else { + throw new RuntimeException(("Illegal union index for 'F948': "+ unionIndex948)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex949 = (decoder.readIndex()); + if (unionIndex949 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(949, null); + } else { + if (unionIndex949 == 1) { + Utf8 charSequence949; + Object oldString949 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(949); + if (oldString949 instanceof Utf8) { + charSequence949 = (decoder).readString(((Utf8) oldString949)); + } else { + charSequence949 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(949, charSequence949); + } else { + throw new RuntimeException(("Illegal union index for 'F949': "+ unionIndex949)); + } + } + int unionIndex950 = (decoder.readIndex()); + if (unionIndex950 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(950, null); + } else { + if (unionIndex950 == 1) { + Utf8 charSequence950; + Object oldString950 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(950); + if (oldString950 instanceof Utf8) { + charSequence950 = (decoder).readString(((Utf8) oldString950)); + } else { + charSequence950 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(950, charSequence950); + } else { + throw new RuntimeException(("Illegal union index for 'F950': "+ unionIndex950)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex951 = (decoder.readIndex()); + if (unionIndex951 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(951, null); + } else { + if (unionIndex951 == 1) { + Utf8 charSequence951; + Object oldString951 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(951); + if (oldString951 instanceof Utf8) { + charSequence951 = (decoder).readString(((Utf8) oldString951)); + } else { + charSequence951 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(951, charSequence951); + } else { + throw new RuntimeException(("Illegal union index for 'F951': "+ unionIndex951)); + } + } + int unionIndex952 = (decoder.readIndex()); + if (unionIndex952 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(952, null); + } else { + if (unionIndex952 == 1) { + Utf8 charSequence952; + Object oldString952 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(952); + if (oldString952 instanceof Utf8) { + charSequence952 = (decoder).readString(((Utf8) oldString952)); + } else { + charSequence952 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(952, charSequence952); + } else { + throw new RuntimeException(("Illegal union index for 'F952': "+ unionIndex952)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex953 = (decoder.readIndex()); + if (unionIndex953 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(953, null); + } else { + if (unionIndex953 == 1) { + Utf8 charSequence953; + Object oldString953 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(953); + if (oldString953 instanceof Utf8) { + charSequence953 = (decoder).readString(((Utf8) oldString953)); + } else { + charSequence953 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(953, charSequence953); + } else { + throw new RuntimeException(("Illegal union index for 'F953': "+ unionIndex953)); + } + } + int unionIndex954 = (decoder.readIndex()); + if (unionIndex954 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(954, null); + } else { + if (unionIndex954 == 1) { + Utf8 charSequence954; + Object oldString954 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(954); + if (oldString954 instanceof Utf8) { + charSequence954 = (decoder).readString(((Utf8) oldString954)); + } else { + charSequence954 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(954, charSequence954); + } else { + throw new RuntimeException(("Illegal union index for 'F954': "+ unionIndex954)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex955 = (decoder.readIndex()); + if (unionIndex955 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(955, null); + } else { + if (unionIndex955 == 1) { + Utf8 charSequence955; + Object oldString955 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(955); + if (oldString955 instanceof Utf8) { + charSequence955 = (decoder).readString(((Utf8) oldString955)); + } else { + charSequence955 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(955, charSequence955); + } else { + throw new RuntimeException(("Illegal union index for 'F955': "+ unionIndex955)); + } + } + int unionIndex956 = (decoder.readIndex()); + if (unionIndex956 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(956, null); + } else { + if (unionIndex956 == 1) { + Utf8 charSequence956; + Object oldString956 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(956); + if (oldString956 instanceof Utf8) { + charSequence956 = (decoder).readString(((Utf8) oldString956)); + } else { + charSequence956 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(956, charSequence956); + } else { + throw new RuntimeException(("Illegal union index for 'F956': "+ unionIndex956)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex957 = (decoder.readIndex()); + if (unionIndex957 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(957, null); + } else { + if (unionIndex957 == 1) { + Utf8 charSequence957; + Object oldString957 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(957); + if (oldString957 instanceof Utf8) { + charSequence957 = (decoder).readString(((Utf8) oldString957)); + } else { + charSequence957 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(957, charSequence957); + } else { + throw new RuntimeException(("Illegal union index for 'F957': "+ unionIndex957)); + } + } + int unionIndex958 = (decoder.readIndex()); + if (unionIndex958 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(958, null); + } else { + if (unionIndex958 == 1) { + Utf8 charSequence958; + Object oldString958 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(958); + if (oldString958 instanceof Utf8) { + charSequence958 = (decoder).readString(((Utf8) oldString958)); + } else { + charSequence958 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(958, charSequence958); + } else { + throw new RuntimeException(("Illegal union index for 'F958': "+ unionIndex958)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex959 = (decoder.readIndex()); + if (unionIndex959 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(959, null); + } else { + if (unionIndex959 == 1) { + Utf8 charSequence959; + Object oldString959 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(959); + if (oldString959 instanceof Utf8) { + charSequence959 = (decoder).readString(((Utf8) oldString959)); + } else { + charSequence959 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(959, charSequence959); + } else { + throw new RuntimeException(("Illegal union index for 'F959': "+ unionIndex959)); + } + } + int unionIndex960 = (decoder.readIndex()); + if (unionIndex960 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(960, null); + } else { + if (unionIndex960 == 1) { + Utf8 charSequence960; + Object oldString960 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(960); + if (oldString960 instanceof Utf8) { + charSequence960 = (decoder).readString(((Utf8) oldString960)); + } else { + charSequence960 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(960, charSequence960); + } else { + throw new RuntimeException(("Illegal union index for 'F960': "+ unionIndex960)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex961 = (decoder.readIndex()); + if (unionIndex961 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(961, null); + } else { + if (unionIndex961 == 1) { + Utf8 charSequence961; + Object oldString961 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(961); + if (oldString961 instanceof Utf8) { + charSequence961 = (decoder).readString(((Utf8) oldString961)); + } else { + charSequence961 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(961, charSequence961); + } else { + throw new RuntimeException(("Illegal union index for 'F961': "+ unionIndex961)); + } + } + int unionIndex962 = (decoder.readIndex()); + if (unionIndex962 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(962, null); + } else { + if (unionIndex962 == 1) { + Utf8 charSequence962; + Object oldString962 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(962); + if (oldString962 instanceof Utf8) { + charSequence962 = (decoder).readString(((Utf8) oldString962)); + } else { + charSequence962 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(962, charSequence962); + } else { + throw new RuntimeException(("Illegal union index for 'F962': "+ unionIndex962)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex963 = (decoder.readIndex()); + if (unionIndex963 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(963, null); + } else { + if (unionIndex963 == 1) { + Utf8 charSequence963; + Object oldString963 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(963); + if (oldString963 instanceof Utf8) { + charSequence963 = (decoder).readString(((Utf8) oldString963)); + } else { + charSequence963 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(963, charSequence963); + } else { + throw new RuntimeException(("Illegal union index for 'F963': "+ unionIndex963)); + } + } + int unionIndex964 = (decoder.readIndex()); + if (unionIndex964 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(964, null); + } else { + if (unionIndex964 == 1) { + Utf8 charSequence964; + Object oldString964 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(964); + if (oldString964 instanceof Utf8) { + charSequence964 = (decoder).readString(((Utf8) oldString964)); + } else { + charSequence964 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(964, charSequence964); + } else { + throw new RuntimeException(("Illegal union index for 'F964': "+ unionIndex964)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex965 = (decoder.readIndex()); + if (unionIndex965 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(965, null); + } else { + if (unionIndex965 == 1) { + Utf8 charSequence965; + Object oldString965 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(965); + if (oldString965 instanceof Utf8) { + charSequence965 = (decoder).readString(((Utf8) oldString965)); + } else { + charSequence965 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(965, charSequence965); + } else { + throw new RuntimeException(("Illegal union index for 'F965': "+ unionIndex965)); + } + } + int unionIndex966 = (decoder.readIndex()); + if (unionIndex966 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(966, null); + } else { + if (unionIndex966 == 1) { + Utf8 charSequence966; + Object oldString966 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(966); + if (oldString966 instanceof Utf8) { + charSequence966 = (decoder).readString(((Utf8) oldString966)); + } else { + charSequence966 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(966, charSequence966); + } else { + throw new RuntimeException(("Illegal union index for 'F966': "+ unionIndex966)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex967 = (decoder.readIndex()); + if (unionIndex967 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(967, null); + } else { + if (unionIndex967 == 1) { + Utf8 charSequence967; + Object oldString967 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(967); + if (oldString967 instanceof Utf8) { + charSequence967 = (decoder).readString(((Utf8) oldString967)); + } else { + charSequence967 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(967, charSequence967); + } else { + throw new RuntimeException(("Illegal union index for 'F967': "+ unionIndex967)); + } + } + int unionIndex968 = (decoder.readIndex()); + if (unionIndex968 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(968, null); + } else { + if (unionIndex968 == 1) { + Utf8 charSequence968; + Object oldString968 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(968); + if (oldString968 instanceof Utf8) { + charSequence968 = (decoder).readString(((Utf8) oldString968)); + } else { + charSequence968 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(968, charSequence968); + } else { + throw new RuntimeException(("Illegal union index for 'F968': "+ unionIndex968)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex969 = (decoder.readIndex()); + if (unionIndex969 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(969, null); + } else { + if (unionIndex969 == 1) { + Utf8 charSequence969; + Object oldString969 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(969); + if (oldString969 instanceof Utf8) { + charSequence969 = (decoder).readString(((Utf8) oldString969)); + } else { + charSequence969 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(969, charSequence969); + } else { + throw new RuntimeException(("Illegal union index for 'F969': "+ unionIndex969)); + } + } + int unionIndex970 = (decoder.readIndex()); + if (unionIndex970 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(970, null); + } else { + if (unionIndex970 == 1) { + Utf8 charSequence970; + Object oldString970 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(970); + if (oldString970 instanceof Utf8) { + charSequence970 = (decoder).readString(((Utf8) oldString970)); + } else { + charSequence970 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(970, charSequence970); + } else { + throw new RuntimeException(("Illegal union index for 'F970': "+ unionIndex970)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex971 = (decoder.readIndex()); + if (unionIndex971 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(971, null); + } else { + if (unionIndex971 == 1) { + Utf8 charSequence971; + Object oldString971 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(971); + if (oldString971 instanceof Utf8) { + charSequence971 = (decoder).readString(((Utf8) oldString971)); + } else { + charSequence971 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(971, charSequence971); + } else { + throw new RuntimeException(("Illegal union index for 'F971': "+ unionIndex971)); + } + } + int unionIndex972 = (decoder.readIndex()); + if (unionIndex972 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(972, null); + } else { + if (unionIndex972 == 1) { + Utf8 charSequence972; + Object oldString972 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(972); + if (oldString972 instanceof Utf8) { + charSequence972 = (decoder).readString(((Utf8) oldString972)); + } else { + charSequence972 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(972, charSequence972); + } else { + throw new RuntimeException(("Illegal union index for 'F972': "+ unionIndex972)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex973 = (decoder.readIndex()); + if (unionIndex973 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(973, null); + } else { + if (unionIndex973 == 1) { + Utf8 charSequence973; + Object oldString973 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(973); + if (oldString973 instanceof Utf8) { + charSequence973 = (decoder).readString(((Utf8) oldString973)); + } else { + charSequence973 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(973, charSequence973); + } else { + throw new RuntimeException(("Illegal union index for 'F973': "+ unionIndex973)); + } + } + int unionIndex974 = (decoder.readIndex()); + if (unionIndex974 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(974, null); + } else { + if (unionIndex974 == 1) { + Utf8 charSequence974; + Object oldString974 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(974); + if (oldString974 instanceof Utf8) { + charSequence974 = (decoder).readString(((Utf8) oldString974)); + } else { + charSequence974 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(974, charSequence974); + } else { + throw new RuntimeException(("Illegal union index for 'F974': "+ unionIndex974)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex975 = (decoder.readIndex()); + if (unionIndex975 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(975, null); + } else { + if (unionIndex975 == 1) { + Utf8 charSequence975; + Object oldString975 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(975); + if (oldString975 instanceof Utf8) { + charSequence975 = (decoder).readString(((Utf8) oldString975)); + } else { + charSequence975 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(975, charSequence975); + } else { + throw new RuntimeException(("Illegal union index for 'F975': "+ unionIndex975)); + } + } + int unionIndex976 = (decoder.readIndex()); + if (unionIndex976 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(976, null); + } else { + if (unionIndex976 == 1) { + Utf8 charSequence976; + Object oldString976 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(976); + if (oldString976 instanceof Utf8) { + charSequence976 = (decoder).readString(((Utf8) oldString976)); + } else { + charSequence976 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(976, charSequence976); + } else { + throw new RuntimeException(("Illegal union index for 'F976': "+ unionIndex976)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex977 = (decoder.readIndex()); + if (unionIndex977 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(977, null); + } else { + if (unionIndex977 == 1) { + Utf8 charSequence977; + Object oldString977 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(977); + if (oldString977 instanceof Utf8) { + charSequence977 = (decoder).readString(((Utf8) oldString977)); + } else { + charSequence977 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(977, charSequence977); + } else { + throw new RuntimeException(("Illegal union index for 'F977': "+ unionIndex977)); + } + } + int unionIndex978 = (decoder.readIndex()); + if (unionIndex978 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(978, null); + } else { + if (unionIndex978 == 1) { + Utf8 charSequence978; + Object oldString978 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(978); + if (oldString978 instanceof Utf8) { + charSequence978 = (decoder).readString(((Utf8) oldString978)); + } else { + charSequence978 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(978, charSequence978); + } else { + throw new RuntimeException(("Illegal union index for 'F978': "+ unionIndex978)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex979 = (decoder.readIndex()); + if (unionIndex979 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(979, null); + } else { + if (unionIndex979 == 1) { + Utf8 charSequence979; + Object oldString979 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(979); + if (oldString979 instanceof Utf8) { + charSequence979 = (decoder).readString(((Utf8) oldString979)); + } else { + charSequence979 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(979, charSequence979); + } else { + throw new RuntimeException(("Illegal union index for 'F979': "+ unionIndex979)); + } + } + int unionIndex980 = (decoder.readIndex()); + if (unionIndex980 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(980, null); + } else { + if (unionIndex980 == 1) { + Utf8 charSequence980; + Object oldString980 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(980); + if (oldString980 instanceof Utf8) { + charSequence980 = (decoder).readString(((Utf8) oldString980)); + } else { + charSequence980 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(980, charSequence980); + } else { + throw new RuntimeException(("Illegal union index for 'F980': "+ unionIndex980)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex981 = (decoder.readIndex()); + if (unionIndex981 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(981, null); + } else { + if (unionIndex981 == 1) { + Utf8 charSequence981; + Object oldString981 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(981); + if (oldString981 instanceof Utf8) { + charSequence981 = (decoder).readString(((Utf8) oldString981)); + } else { + charSequence981 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(981, charSequence981); + } else { + throw new RuntimeException(("Illegal union index for 'F981': "+ unionIndex981)); + } + } + int unionIndex982 = (decoder.readIndex()); + if (unionIndex982 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(982, null); + } else { + if (unionIndex982 == 1) { + Utf8 charSequence982; + Object oldString982 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(982); + if (oldString982 instanceof Utf8) { + charSequence982 = (decoder).readString(((Utf8) oldString982)); + } else { + charSequence982 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(982, charSequence982); + } else { + throw new RuntimeException(("Illegal union index for 'F982': "+ unionIndex982)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex983 = (decoder.readIndex()); + if (unionIndex983 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(983, null); + } else { + if (unionIndex983 == 1) { + Utf8 charSequence983; + Object oldString983 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(983); + if (oldString983 instanceof Utf8) { + charSequence983 = (decoder).readString(((Utf8) oldString983)); + } else { + charSequence983 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(983, charSequence983); + } else { + throw new RuntimeException(("Illegal union index for 'F983': "+ unionIndex983)); + } + } + int unionIndex984 = (decoder.readIndex()); + if (unionIndex984 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(984, null); + } else { + if (unionIndex984 == 1) { + Utf8 charSequence984; + Object oldString984 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(984); + if (oldString984 instanceof Utf8) { + charSequence984 = (decoder).readString(((Utf8) oldString984)); + } else { + charSequence984 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(984, charSequence984); + } else { + throw new RuntimeException(("Illegal union index for 'F984': "+ unionIndex984)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex985 = (decoder.readIndex()); + if (unionIndex985 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(985, null); + } else { + if (unionIndex985 == 1) { + Utf8 charSequence985; + Object oldString985 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(985); + if (oldString985 instanceof Utf8) { + charSequence985 = (decoder).readString(((Utf8) oldString985)); + } else { + charSequence985 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(985, charSequence985); + } else { + throw new RuntimeException(("Illegal union index for 'F985': "+ unionIndex985)); + } + } + int unionIndex986 = (decoder.readIndex()); + if (unionIndex986 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(986, null); + } else { + if (unionIndex986 == 1) { + Utf8 charSequence986; + Object oldString986 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(986); + if (oldString986 instanceof Utf8) { + charSequence986 = (decoder).readString(((Utf8) oldString986)); + } else { + charSequence986 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(986, charSequence986); + } else { + throw new RuntimeException(("Illegal union index for 'F986': "+ unionIndex986)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex987 = (decoder.readIndex()); + if (unionIndex987 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(987, null); + } else { + if (unionIndex987 == 1) { + Utf8 charSequence987; + Object oldString987 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(987); + if (oldString987 instanceof Utf8) { + charSequence987 = (decoder).readString(((Utf8) oldString987)); + } else { + charSequence987 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(987, charSequence987); + } else { + throw new RuntimeException(("Illegal union index for 'F987': "+ unionIndex987)); + } + } + int unionIndex988 = (decoder.readIndex()); + if (unionIndex988 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(988, null); + } else { + if (unionIndex988 == 1) { + Utf8 charSequence988; + Object oldString988 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(988); + if (oldString988 instanceof Utf8) { + charSequence988 = (decoder).readString(((Utf8) oldString988)); + } else { + charSequence988 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(988, charSequence988); + } else { + throw new RuntimeException(("Illegal union index for 'F988': "+ unionIndex988)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex989 = (decoder.readIndex()); + if (unionIndex989 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(989, null); + } else { + if (unionIndex989 == 1) { + Utf8 charSequence989; + Object oldString989 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(989); + if (oldString989 instanceof Utf8) { + charSequence989 = (decoder).readString(((Utf8) oldString989)); + } else { + charSequence989 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(989, charSequence989); + } else { + throw new RuntimeException(("Illegal union index for 'F989': "+ unionIndex989)); + } + } + int unionIndex990 = (decoder.readIndex()); + if (unionIndex990 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(990, null); + } else { + if (unionIndex990 == 1) { + Utf8 charSequence990; + Object oldString990 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(990); + if (oldString990 instanceof Utf8) { + charSequence990 = (decoder).readString(((Utf8) oldString990)); + } else { + charSequence990 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(990, charSequence990); + } else { + throw new RuntimeException(("Illegal union index for 'F990': "+ unionIndex990)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex991 = (decoder.readIndex()); + if (unionIndex991 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(991, null); + } else { + if (unionIndex991 == 1) { + Utf8 charSequence991; + Object oldString991 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(991); + if (oldString991 instanceof Utf8) { + charSequence991 = (decoder).readString(((Utf8) oldString991)); + } else { + charSequence991 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(991, charSequence991); + } else { + throw new RuntimeException(("Illegal union index for 'F991': "+ unionIndex991)); + } + } + int unionIndex992 = (decoder.readIndex()); + if (unionIndex992 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(992, null); + } else { + if (unionIndex992 == 1) { + Utf8 charSequence992; + Object oldString992 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(992); + if (oldString992 instanceof Utf8) { + charSequence992 = (decoder).readString(((Utf8) oldString992)); + } else { + charSequence992 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(992, charSequence992); + } else { + throw new RuntimeException(("Illegal union index for 'F992': "+ unionIndex992)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex993 = (decoder.readIndex()); + if (unionIndex993 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(993, null); + } else { + if (unionIndex993 == 1) { + Utf8 charSequence993; + Object oldString993 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(993); + if (oldString993 instanceof Utf8) { + charSequence993 = (decoder).readString(((Utf8) oldString993)); + } else { + charSequence993 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(993, charSequence993); + } else { + throw new RuntimeException(("Illegal union index for 'F993': "+ unionIndex993)); + } + } + int unionIndex994 = (decoder.readIndex()); + if (unionIndex994 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(994, null); + } else { + if (unionIndex994 == 1) { + Utf8 charSequence994; + Object oldString994 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(994); + if (oldString994 instanceof Utf8) { + charSequence994 = (decoder).readString(((Utf8) oldString994)); + } else { + charSequence994 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(994, charSequence994); + } else { + throw new RuntimeException(("Illegal union index for 'F994': "+ unionIndex994)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex995 = (decoder.readIndex()); + if (unionIndex995 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(995, null); + } else { + if (unionIndex995 == 1) { + Utf8 charSequence995; + Object oldString995 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(995); + if (oldString995 instanceof Utf8) { + charSequence995 = (decoder).readString(((Utf8) oldString995)); + } else { + charSequence995 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(995, charSequence995); + } else { + throw new RuntimeException(("Illegal union index for 'F995': "+ unionIndex995)); + } + } + int unionIndex996 = (decoder.readIndex()); + if (unionIndex996 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(996, null); + } else { + if (unionIndex996 == 1) { + Utf8 charSequence996; + Object oldString996 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(996); + if (oldString996 instanceof Utf8) { + charSequence996 = (decoder).readString(((Utf8) oldString996)); + } else { + charSequence996 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(996, charSequence996); + } else { + throw new RuntimeException(("Illegal union index for 'F996': "+ unionIndex996)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex997 = (decoder.readIndex()); + if (unionIndex997 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(997, null); + } else { + if (unionIndex997 == 1) { + Utf8 charSequence997; + Object oldString997 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(997); + if (oldString997 instanceof Utf8) { + charSequence997 = (decoder).readString(((Utf8) oldString997)); + } else { + charSequence997 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(997, charSequence997); + } else { + throw new RuntimeException(("Illegal union index for 'F997': "+ unionIndex997)); + } + } + int unionIndex998 = (decoder.readIndex()); + if (unionIndex998 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(998, null); + } else { + if (unionIndex998 == 1) { + Utf8 charSequence998; + Object oldString998 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(998); + if (oldString998 instanceof Utf8) { + charSequence998 = (decoder).readString(((Utf8) oldString998)); + } else { + charSequence998 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(998, charSequence998); + } else { + throw new RuntimeException(("Illegal union index for 'F998': "+ unionIndex998)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex999 = (decoder.readIndex()); + if (unionIndex999 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(999, null); + } else { + if (unionIndex999 == 1) { + Utf8 charSequence999; + Object oldString999 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(999); + if (oldString999 instanceof Utf8) { + charSequence999 = (decoder).readString(((Utf8) oldString999)); + } else { + charSequence999 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(999, charSequence999); + } else { + throw new RuntimeException(("Illegal union index for 'F999': "+ unionIndex999)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java new file mode 100644 index 000000000..7ce9e779a --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java @@ -0,0 +1,122 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Schema testEnumUnion0; + private final Schema testEnumArray0; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadEnum = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadEnum = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(0, new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0 .getEnumSymbols().get((decoder.readEnum())))); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum1((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(1, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(1, new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0 .getEnumSymbols().get((decoder.readEnum())))); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadEnum.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + testEnumArray1 .clear(); + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadEnum.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + testEnumUnionArray1 .clear(); + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testFixed0; + private final Schema testFixedUnion0; + private final Schema testFixedArray0; + private final Schema testFixedUnionArray0; + private final Schema testFixedUnionArrayArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadFixed_GenericDeserializer_1590965143_1590965143(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testFixed0 = readerSchema.getField("testFixed").schema(); + this.testFixedUnion0 = readerSchema.getField("testFixedUnion").schema(); + this.testFixedArray0 = readerSchema.getField("testFixedArray").schema(); + this.testFixedUnionArray0 = readerSchema.getField("testFixedUnionArray").schema(); + this.testFixedUnionArrayArrayElemSchema0 = testFixedUnionArray0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadFixed = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadFixed = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + byte[] testFixed1; + Object oldFixed0 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(0); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (2))) { + testFixed1 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed1 = ( new byte[2]); + } + decoder.readFixed(testFixed1); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(0, new org.apache.avro.generic.GenericData.Fixed(testFixed1)); + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed1((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadFixed; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(1, null); + } else { + if (unionIndex0 == 1) { + byte[] testFixed2; + Object oldFixed1 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(1); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (2))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[2]); + } + decoder.readFixed(testFixed2); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(1, new org.apache.avro.generic.GenericData.Fixed(testFixed2)); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex0)); + } + } + List testFixedArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(2); + if (oldArray0 instanceof List) { + testFixedArray1 = ((List) oldArray0); + testFixedArray1 .clear(); + } else { + testFixedArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testFixedArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(3); + if (oldArray1 instanceof List) { + testFixedUnionArray1 = ((List) oldArray1); + testFixedUnionArray1 .clear(); + } else { + testFixedUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testFixedUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema union0; + private final Schema unionOptionSchema0; + private final Schema subField0; + + public FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion_GenericDeserializer_2643982_2643982(Schema readerSchema) { + this.readerSchema = readerSchema; + this.union0 = readerSchema.getField("union").schema(); + this.unionOptionSchema0 = union0 .getTypes().get(1); + this.subField0 = unionOptionSchema0 .getField("subField").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, charSequence1); + } else { + if (unionIndex0 == 3) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + } + return FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == unionOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(unionOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java new file mode 100644 index 000000000..fd7ad9856 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java @@ -0,0 +1,129 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema mapField0; + private final Schema mapFieldMapValueSchema0; + private final Schema mapFieldValueMapValueSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapField0 = readerSchema.getField("mapField").schema(); + this.mapFieldMapValueSchema0 = mapField0 .getValueType(); + this.mapFieldValueMapValueSchema0 = mapFieldMapValueSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadNestedMap; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadNestedMap = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadNestedMap = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map>> mapField1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), ((int) chunkLen0))); + } else { + Map>> mapFieldReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0); + if (oldMap0 instanceof Map) { + mapFieldReuse0 = ((Map) oldMap0); + } + if (mapFieldReuse0 != (null)) { + mapFieldReuse0 .clear(); + mapField1 = mapFieldReuse0; + } else { + mapField1 = new HashMap>>(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 > mapFieldValue0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, ((int) chunkLen1))); + } else { + Map> mapFieldValueReuse0 = null; + if (null instanceof Map) { + mapFieldValueReuse0 = ((Map) null); + } + if (mapFieldValueReuse0 != (null)) { + mapFieldValueReuse0 .clear(); + mapFieldValue0 = mapFieldValueReuse0; + } else { + mapFieldValue0 = new HashMap>(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0) { + for (int counter2 = 0; (counter2 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, 0)); + } else { + mapFieldValue0 = new HashMap>(0); + } + } + mapField1 .put(key0, mapFieldValue0); + } + chunkLen0 = (decoder.mapNext()); + } while (chunkLen0 > 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), 0)); + } else { + mapField1 = new HashMap>>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadNestedMap.put(0, mapField1); + return FastGenericDeserializerGeneratorTest_shouldReadNestedMap; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java new file mode 100644 index 000000000..dd43e9b88 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java @@ -0,0 +1,206 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + private final Schema testEnumUnion0; + private final Map enumMappingtestEnum1; + private final Schema testEnumArray0; + private final Map enumMappingtestEnum2; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + private final Map enumMappingtestEnum3; + + public FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(5); + tempEnumMapping0 .put(new Integer(0), new Integer(1)); + tempEnumMapping0 .put(new Integer(1), new Integer(0)); + tempEnumMapping0 .put(new Integer(2), new Integer(4)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + HashMap tempEnumMapping1 = new HashMap(5); + tempEnumMapping1 .put(new Integer(0), new Integer(1)); + tempEnumMapping1 .put(new Integer(1), new Integer(0)); + tempEnumMapping1 .put(new Integer(2), new Integer(4)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + HashMap tempEnumMapping2 = new HashMap(5); + tempEnumMapping2 .put(new Integer(0), new Integer(1)); + tempEnumMapping2 .put(new Integer(1), new Integer(0)); + tempEnumMapping2 .put(new Integer(2), new Integer(4)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + HashMap tempEnumMapping3 = new HashMap(5); + tempEnumMapping3 .put(new Integer(0), new Integer(1)); + tempEnumMapping3 .put(new Integer(1), new Integer(0)); + tempEnumMapping3 .put(new Integer(2), new Integer(4)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(0, enumValue0); + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum1((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(1, null); + } else { + if (unionIndex0 == 1) { + int enumIndex1 = (decoder.readEnum()); + GenericEnumSymbol enumValue1 = null; + Object enumIndexLookupResult1 = enumMappingtestEnum1 .get(enumIndex1); + if (enumIndexLookupResult1 instanceof Integer) { + enumValue1 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult1))); + } else { + if (enumIndexLookupResult1 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult1); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(1, enumValue1); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + testEnumArray1 .clear(); + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + testEnumUnionArray1 .clear(); + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testIntUnion0; + private final Schema testStringUnion0; + private final Schema testLongUnion0; + private final Schema testDoubleUnion0; + private final Schema testFloatUnion0; + private final Schema testBooleanUnion0; + private final Schema testBytesUnion0; + + public FastGenericDeserializerGeneratorTest_shouldReadPrimitives_GenericDeserializer_1966544736_1966544736(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testIntUnion0 = readerSchema.getField("testIntUnion").schema(); + this.testStringUnion0 = readerSchema.getField("testStringUnion").schema(); + this.testLongUnion0 = readerSchema.getField("testLongUnion").schema(); + this.testDoubleUnion0 = readerSchema.getField("testDoubleUnion").schema(); + this.testFloatUnion0 = readerSchema.getField("testFloatUnion").schema(); + this.testBooleanUnion0 = readerSchema.getField("testBooleanUnion").schema(); + this.testBytesUnion0 = readerSchema.getField("testBytesUnion").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(0, (decoder.readInt())); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPrimitives; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(1, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(2); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(2, charSequence0); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(3, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(3); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(3, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(4, (decoder.readLong())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(5, null); + } else { + if (unionIndex2 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(5, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex2)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(6, (decoder.readDouble())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(7, null); + } else { + if (unionIndex3 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(7, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex3)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(8, (decoder.readFloat())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(9, null); + } else { + if (unionIndex4 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(9, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex4)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(10, (decoder.readBoolean())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(11, null); + } else { + if (unionIndex5 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(11, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex5)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(12); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(12, byteBuffer0); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(13, null); + } else { + if (unionIndex6 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(13); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(13, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex6)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java new file mode 100644 index 000000000..7baa181ec --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java @@ -0,0 +1,160 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema record10; + private final Schema subField0; + private final Schema intFieldField0; + private final Schema intField0; + private final Schema subField1; + private final Schema recordArray0; + + public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record10 = readerSchema.getField("record1").schema(); + this.subField0 = record10 .getField("subField").schema(); + this.intFieldField0 = record10 .getField("intField").schema(); + this.intField0 = record10 .getField("intField").schema(); + this.subField1 = record10 .getField("subField").schema(); + this.recordArray0 = readerSchema.getField("recordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord aliasedSubRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == record10)) { + aliasedSubRecord = ((IndexedRecord)(reuse)); + } else { + aliasedSubRecord = new org.apache.avro.generic.GenericData.Record(record10); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + aliasedSubRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = aliasedSubRecord.get(1); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + aliasedSubRecord.put(1, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex0)); + } + } + aliasedSubRecord.put(0, null); + return aliasedSubRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord1(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); + List recordArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); + if (oldArray0 instanceof List) { + recordArray1 = ((List) oldArray0); + recordArray1 .clear(); + } else { + recordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema record10; + private final Schema subField0; + private final Schema record20; + private final Schema intField0; + private final Schema subField1; + private final Schema recordArray0; + + public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1365753944_1274815349(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record10 = readerSchema.getField("record1").schema(); + this.subField0 = record10 .getField("subField").schema(); + this.record20 = readerSchema.getField("record2").schema(); + this.intField0 = record20 .getField("intField").schema(); + this.subField1 = record20 .getField("subField").schema(); + this.recordArray0 = readerSchema.getField("recordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializealiasedSubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializealiasedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == record10)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(record10); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + decoder.readInt(); + } else { + throw new RuntimeException(("Illegal union index for 'intField': "+ unionIndex0)); + } + } + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); + List recordArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); + if (oldArray0 instanceof List) { + recordArray1 = ((List) oldArray0); + recordArray1 .clear(); + } else { + recordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema recordsArray0; + private final Schema recordsArrayArrayElemSchema0; + private final Schema subField0; + private final Schema recordsMap0; + private final Schema recordsArrayUnion0; + private final Schema recordsArrayUnionOptionSchema0; + private final Schema recordsArrayUnionOptionArrayElemSchema0; + private final Schema recordsMapUnion0; + private final Schema recordsMapUnionOptionSchema0; + private final Schema recordsMapUnionOptionMapValueSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField_GenericDeserializer_1602399407_1602399407(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordsArray0 = readerSchema.getField("recordsArray").schema(); + this.recordsArrayArrayElemSchema0 = recordsArray0 .getElementType(); + this.subField0 = recordsArrayArrayElemSchema0 .getField("subField").schema(); + this.recordsMap0 = readerSchema.getField("recordsMap").schema(); + this.recordsArrayUnion0 = readerSchema.getField("recordsArrayUnion").schema(); + this.recordsArrayUnionOptionSchema0 = recordsArrayUnion0 .getTypes().get(1); + this.recordsArrayUnionOptionArrayElemSchema0 = recordsArrayUnionOptionSchema0 .getElementType(); + this.recordsMapUnion0 = readerSchema.getField("recordsMapUnion").schema(); + this.recordsMapUnionOptionSchema0 = recordsMapUnion0 .getTypes().get(1); + this.recordsMapUnionOptionMapValueSchema0 = recordsMapUnionOptionSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List recordsArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(0); + if (oldArray0 instanceof List) { + recordsArray1 = ((List) oldArray0); + recordsArray1 .clear(); + } else { + recordsArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordsArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 recordsMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), ((int) chunkLen1))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap1 = recordsMapReuse0; + } else { + recordsMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), 0)); + } else { + recordsMap1 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(1, recordsMap1); + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(2, null); + } else { + if (unionIndex1 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(2); + if (oldArray1 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray1); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen2), recordsArrayUnionOptionSchema0); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 recordsMapUnionOption0 = null; + long chunkLen3 = (decoder.readMapStart()); + if (chunkLen3 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), ((int) chunkLen3))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); + } + } + do { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(3, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex3)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java new file mode 100644 index 000000000..dc99989e8 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java @@ -0,0 +1,378 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema recordsArrayMap0; + private final Schema recordsArrayMapArrayElemSchema0; + private final Schema recordsArrayMapElemMapValueSchema0; + private final Schema recordsArrayMapElemValueOptionSchema0; + private final Schema subField0; + private final Schema recordsMapArray0; + private final Schema recordsMapArrayMapValueSchema0; + private final Schema recordsMapArrayValueArrayElemSchema0; + private final Schema recordsArrayMapUnion0; + private final Schema recordsArrayMapUnionOptionArrayElemSchema0; + private final Schema recordsArrayMapUnionOptionElemMapValueSchema0; + private final Schema recordsMapArrayUnion0; + private final Schema recordsMapArrayUnionOptionSchema0; + private final Schema recordsMapArrayUnionOptionValueArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordsArrayMap0 = readerSchema.getField("recordsArrayMap").schema(); + this.recordsArrayMapArrayElemSchema0 = recordsArrayMap0 .getElementType(); + this.recordsArrayMapElemMapValueSchema0 = recordsArrayMapArrayElemSchema0 .getValueType(); + this.recordsArrayMapElemValueOptionSchema0 = recordsArrayMapElemMapValueSchema0 .getTypes().get(1); + this.subField0 = recordsArrayMapElemValueOptionSchema0 .getField("subField").schema(); + this.recordsMapArray0 = readerSchema.getField("recordsMapArray").schema(); + this.recordsMapArrayMapValueSchema0 = recordsMapArray0 .getValueType(); + this.recordsMapArrayValueArrayElemSchema0 = recordsMapArrayMapValueSchema0 .getElementType(); + this.recordsArrayMapUnion0 = readerSchema.getField("recordsArrayMapUnion").schema(); + this.recordsArrayMapUnionOptionArrayElemSchema0 = recordsArrayMap0 .getElementType(); + this.recordsArrayMapUnionOptionElemMapValueSchema0 = recordsArrayMapUnionOptionArrayElemSchema0 .getValueType(); + this.recordsMapArrayUnion0 = readerSchema.getField("recordsMapArrayUnion").schema(); + this.recordsMapArrayUnionOptionSchema0 = recordsMapArrayUnion0 .getTypes().get(1); + this.recordsMapArrayUnionOptionValueArrayElemSchema0 = recordsMapArrayMapValueSchema0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List> recordsArrayMap1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(0); + if (oldArray0 instanceof List) { + recordsArrayMap1 = ((List) oldArray0); + recordsArrayMap1 .clear(); + } else { + recordsArrayMap1 = new org.apache.avro.generic.GenericData.Array>(((int) chunkLen0), recordsArrayMap0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 recordsArrayMapElem0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen1))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap1 .add(recordsArrayMapElem0); + } + chunkLen0 = (decoder.arrayNext()); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(0, recordsArrayMap1); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordsArrayMapElemValueOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(recordsArrayMapElemValueOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray1 = null; + long chunkLen2 = (decoder.readMapStart()); + if (chunkLen2 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), ((int) chunkLen2))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap0); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray1 = recordsMapArrayReuse0; + } else { + recordsMapArray1 = new HashMap>(((int)(((chunkLen2 * 4)+ 2)/ 3))); + } + } + do { + for (int counter2 = 0; (counter2 recordsMapArrayValue0 = null; + long chunkLen3 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen3), recordsMapArrayMapValueSchema0); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), 0)); + } else { + recordsMapArray1 = new HashMap>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(1, recordsMapArray1); + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(2, null); + } else { + if (unionIndex3 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(2); + if (oldArray1 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray1); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new org.apache.avro.generic.GenericData.Array>(((int) chunkLen4), recordsArrayMap0); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArrayMapUnionOptionElem0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen5))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen4 = (decoder.arrayNext()); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(2, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex3)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(3, null); + } else { + if (unionIndex5 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), ((int) chunkLen6))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 recordsMapArrayUnionOptionValue0 = null; + long chunkLen7 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen7), recordsMapArrayMapValueSchema0); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(3, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex5)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java new file mode 100644 index 000000000..15243ea4c --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java @@ -0,0 +1,114 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema record0; + private final Schema recordOptionSchema0; + private final Schema subField0; + private final Schema field0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record0 = readerSchema.getField("record").schema(); + this.recordOptionSchema0 = record0 .getTypes().get(1); + this.subField0 = recordOptionSchema0 .getField("subField").schema(); + this.field0 = readerSchema.getField("field").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'record': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(recordOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(1), (decoder), (customization))); + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(2, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(2); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(2, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex2)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java new file mode 100644 index 000000000..a2ab07fb6 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java @@ -0,0 +1,252 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testNotRemoved0; + private final Schema testNotRemoved20; + private final Schema subRecord0; + private final Schema subRecordOptionSchema0; + private final Schema testNotRemoved1; + private final Schema testNotRemoved21; + private final Schema subRecordMap0; + private final Schema subRecordArray0; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testNotRemoved0 = readerSchema.getField("testNotRemoved").schema(); + this.testNotRemoved20 = readerSchema.getField("testNotRemoved2").schema(); + this.subRecord0 = readerSchema.getField("subRecord").schema(); + this.subRecordOptionSchema0 = subRecord0 .getTypes().get(1); + this.testNotRemoved1 = subRecordOptionSchema0 .getField("testNotRemoved").schema(); + this.testNotRemoved21 = subRecordOptionSchema0 .getField("testNotRemoved2").schema(); + this.subRecordMap0 = readerSchema.getField("subRecordMap").schema(); + this.subRecordArray0 = readerSchema.getField("subRecordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + } else { + if (unionIndex1 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testRemoved': "+ unionIndex1)); + } + } + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(1, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved2': "+ unionIndex2)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, null); + } else { + if (unionIndex3 == 1) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(2), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex3)); + } + } + Map subRecordMap1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), ((int) chunkLen0))); + } else { + Map subRecordMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3); + if (oldMap0 instanceof Map) { + subRecordMapReuse0 = ((Map) oldMap0); + } + if (subRecordMapReuse0 != (null)) { + subRecordMapReuse0 .clear(); + subRecordMap1 = subRecordMapReuse0; + } else { + subRecordMap1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), 0)); + } else { + subRecordMap1 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(3, subRecordMap1); + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecordOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecordOptionSchema0); + } + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex4 == 1) { + Utf8 charSequence2; + Object oldString2 = subRecord.get(0); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + subRecord.put(0, charSequence2); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex4)); + } + } + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + } else { + if (unionIndex5 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testRemoved': "+ unionIndex5)); + } + } + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + subRecord.put(1, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence3; + Object oldString3 = subRecord.get(1); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + subRecord.put(1, charSequence3); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved2': "+ unionIndex6)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List subRecordArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(4); + if (oldArray0 instanceof List) { + subRecordArray1 = ((List) oldArray0); + subRecordArray1 .clear(); + } else { + subRecordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), subRecordArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema subRecord0; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord_GenericDeserializer_1090641932_438987109(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.get(0), (decoder), (customization))); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord0); + } + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + populate_subRecord0((subRecord), (customization), (decoder)); + populate_subRecord1((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubSubRecord0(null, (decoder), (customization)); + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + deserializesubSubRecord0(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'test3': "+ unionIndex0)); + } + } + } + + public void deserializesubSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + populate_subSubRecord0((decoder)); + } + + private void populate_subSubRecord0(Decoder decoder) + throws IOException + { + decoder.skipString(); + } + + private void populate_subRecord1(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = subRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + subRecord.put(1, charSequence1); + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java new file mode 100644 index 000000000..9332a081a --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java @@ -0,0 +1,114 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema subRecord10; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord10 = readerSchema.getField("subRecord1").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord10)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord10); + } + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = subRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + subRecord.put(1, charSequence1); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubRecord20(null, (decoder), (customization)); + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + deserializesubRecord20(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord3': "+ unionIndex0)); + } + } + } + + public void deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + populate_subRecord20((decoder)); + } + + private void populate_subRecord20(Decoder decoder) + throws IOException + { + decoder.skipString(); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(1), (decoder), (customization))); + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java new file mode 100644 index 000000000..55ef790c8 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java @@ -0,0 +1,60 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java new file mode 100644 index 000000000..4d5e38fbb --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java @@ -0,0 +1,60 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java new file mode 100644 index 000000000..fa64819c4 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + throw new AvroTypeException("Found \"long\", expecting [\"null\", \"string\"]"); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java new file mode 100644 index 000000000..6b8ca1934 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java new file mode 100644 index 000000000..98253664f --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java new file mode 100644 index 000000000..30e3c0f55 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java new file mode 100644 index 000000000..178228213 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java new file mode 100644 index 000000000..28b7e80c6 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java new file mode 100644 index 000000000..a7447161b --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java @@ -0,0 +1,71 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_906204958(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_1778260273(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.put(0, null); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_906204958(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.put(0, null); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_2127585735(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + if (unionIndex0 == 1) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java new file mode 100644 index 000000000..5bfd91b66 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + if (unionIndex0 == 1) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java new file mode 100644 index 000000000..ac7afbd0f --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + if (unionIndex0 == 1) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java new file mode 100644 index 000000000..c4997b90c --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + if (unionIndex0 == 1) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java new file mode 100644 index 000000000..02287883e --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java new file mode 100644 index 000000000..f8cf6603b --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java new file mode 100644 index 000000000..1b2fb0279 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java new file mode 100644 index 000000000..993ebabf6 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java new file mode 100644 index 000000000..9d619103b --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + this.testOptionSchema1 = test0 .getTypes().get(2); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java new file mode 100644 index 000000000..76b0994d8 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + this.testOptionSchema1 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java new file mode 100644 index 000000000..2d65b1355 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(2); + this.testOptionSchema1 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java new file mode 100644 index 000000000..6b7514a8a --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + this.testOptionSchema1 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java new file mode 100644 index 000000000..caf76e31a --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java @@ -0,0 +1,148 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyInReaderSchemaTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyInReaderSchemaTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence1; + Object oldString1 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + testStringArray1 .clear(); + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java new file mode 100644 index 000000000..4e91bf33f --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java @@ -0,0 +1,148 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyInReaderSchemaTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyInReaderSchemaTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence1; + Object oldString1 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + testStringArray1 .clear(); + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java new file mode 100644 index 000000000..3c16528b8 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java @@ -0,0 +1,148 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = FastStringableTest_javaStringPropertyTest.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyTest0((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyTest1((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyTest; + } + + private void populate_FastStringableTest_javaStringPropertyTest0(IndexedRecord FastStringableTest_javaStringPropertyTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyTest.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence1; + Object oldString1 = FastStringableTest_javaStringPropertyTest.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + testStringArray1 .clear(); + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/Map_of_TestRecord_SpecificDeserializer_627532877_627532877.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/Map_of_TestRecord_SpecificDeserializer_627532877_627532877.java new file mode 100644 index 000000000..8397e3bf9 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/Map_of_TestRecord_SpecificDeserializer_627532877_627532877.java @@ -0,0 +1,1071 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_TestRecord_SpecificDeserializer_627532877_627532877 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Map_of_TestRecord_SpecificDeserializer_627532877_627532877(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex7 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex7)); + } + } + List testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema mapMapValueSchema0; + private final Schema mapValueOptionSchema0; + private final Schema field0; + + public Map_of_UNION_GenericDeserializer_2140000109_2140000109(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapValueSchema0 = readerSchema.getValueType(); + this.mapValueOptionSchema0 = mapMapValueSchema0 .getTypes().get(1); + this.field0 = mapValueOptionSchema0 .getField("field").schema(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapValueOptionSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapValueOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + record.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = record.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + record.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex1)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/Map_of_UNION_SpecificDeserializer_1258242403_1258242403.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/Map_of_UNION_SpecificDeserializer_1258242403_1258242403.java new file mode 100644 index 000000000..a332b8da7 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/Map_of_UNION_SpecificDeserializer_1258242403_1258242403.java @@ -0,0 +1,1081 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_UNION_SpecificDeserializer_1258242403_1258242403 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Map_of_UNION_SpecificDeserializer_1258242403_1258242403(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex1)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex2)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex3)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex4)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex5 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex5)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex6 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex6)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex7 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex7)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + List testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex15 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex17)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex21 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex21)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex23 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex23)); + } + } + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex25 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex25 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex25 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex25)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema unionOptionMapValueSchema0; + + public Map_of_record_GenericDeserializer_1223705675_568621313(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOptionMapValueSchema0 = readerSchema.getValueType(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":{\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}}"); + } else { + if (unionIndex0 == 1) { + Map unionOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map unionOptionReuse0 = null; + if ((reuse) instanceof Map) { + unionOptionReuse0 = ((Map)(reuse)); + } + if (unionOptionReuse0 != (null)) { + unionOptionReuse0 .clear(); + unionOption0 = unionOptionReuse0; + } else { + unionOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + unionOption0 = new HashMap(0); + } + } + return unionOption0; + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == unionOptionMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(unionOptionMapValueSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/Map_of_record_GenericDeserializer_1677529043_1677529043.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/Map_of_record_GenericDeserializer_1677529043_1677529043.java new file mode 100644 index 000000000..e3022984c --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/Map_of_record_GenericDeserializer_1677529043_1677529043.java @@ -0,0 +1,95 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_record_GenericDeserializer_1677529043_1677529043 + implements FastDeserializer> +{ + + private final Schema readerSchema; + private final Schema mapMapValueSchema0; + private final Schema field0; + + public Map_of_record_GenericDeserializer_1677529043_1677529043(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapValueSchema0 = readerSchema.getValueType(); + this.field0 = mapMapValueSchema0 .getField("field").schema(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapMapValueSchema0); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + record.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = record.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + record.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java new file mode 100644 index 000000000..b893cd06f --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java @@ -0,0 +1,61 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserialize(com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRecordWithLargeUnionField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserializeRecordWithLargeUnionField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField RecordWithLargeUnionField; + if ((reuse)!= null) { + RecordWithLargeUnionField = ((com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField)(reuse)); + } else { + RecordWithLargeUnionField = new com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Utf8 charSequence0; + Object oldString0 = RecordWithLargeUnionField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RecordWithLargeUnionField.put(0, charSequence0); + } else { + if (unionIndex0 == 1) { + RecordWithLargeUnionField.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + throw new AvroTypeException(new StringBuilder().append("Found").append(" \"byt").append("es\", ").append("expec").append("ting ").append("[\"str").append("ing\",").append(" \"int").append("\"]").toString()); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + } + return RecordWithLargeUnionField; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java new file mode 100644 index 000000000..d8b84bb11 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java @@ -0,0 +1,47 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; + if ((reuse)!= null) { + RemovedTypesTestRecord = ((com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord)(reuse)); + } else { + RemovedTypesTestRecord = new com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord(); + } + Utf8 charSequence0; + Object oldString0 = RemovedTypesTestRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RemovedTypesTestRecord.put(0, charSequence0); + return RemovedTypesTestRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java new file mode 100644 index 000000000..a4d28dce0 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java @@ -0,0 +1,406 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; + if ((reuse)!= null) { + RemovedTypesTestRecord = ((com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord)(reuse)); + } else { + RemovedTypesTestRecord = new com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord(); + } + Utf8 charSequence0; + Object oldString0 = RemovedTypesTestRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RemovedTypesTestRecord.put(0, charSequence0); + populate_RemovedTypesTestRecord0((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord1((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord2((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord3((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord4((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord5((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord6((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord7((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord8((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord9((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord10((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord11((RemovedTypesTestRecord), (customization), (decoder)); + return RemovedTypesTestRecord; + } + + private void populate_RemovedTypesTestRecord0(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.skipBytes(); + long chunkLen0 = (decoder.readArrayStart()); + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 0) { + do { + for (int counter1 = 0; (counter1 0); + } + } + + private void populate_RemovedTypesTestRecord2(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen2 = (decoder.readArrayStart()); + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 0) { + do { + for (int counter3 = 0; (counter3 0); + } + } + + private void populate_RemovedTypesTestRecord3(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.skipFixed(1); + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + } else { + if (unionIndex3 == 1) { + decoder.skipFixed(1); + } else { + throw new RuntimeException(("Illegal union index for 'removedFixedUnion': "+ unionIndex3)); + } + } + } + + private void populate_RemovedTypesTestRecord4(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen4 = (decoder.readArrayStart()); + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 0) { + do { + for (int counter5 = 0; (counter5 0); + } + } + + private void populate_RemovedTypesTestRecord5(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen6 = (decoder.readArrayStart()); + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 0) { + do { + for (int counter7 = 0; (counter7 0); + } + } + + private void populate_RemovedTypesTestRecord6(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.readEnum(); + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + } else { + if (unionIndex6 == 1) { + decoder.readEnum(); + } else { + throw new RuntimeException(("Illegal union index for 'removedEnumUnion': "+ unionIndex6)); + } + } + } + + private void populate_RemovedTypesTestRecord7(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen8 = (decoder.readArrayStart()); + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 0) { + do { + for (int counter9 = 0; (counter9 0); + } + } + + private void populate_RemovedTypesTestRecord8(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen10 = (decoder.readArrayStart()); + while (chunkLen10 > 0) { + for (int counter10 = 0; (counter10 0) { + do { + for (int counter11 = 0; (counter11 0); + } + } + + private void populate_RemovedTypesTestRecord9(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializeRemovedSubRecord0(null, (decoder), (customization)); + int unionIndex9 = (decoder.readIndex()); + if (unionIndex9 == 0) { + decoder.readNull(); + } else { + if (unionIndex9 == 1) { + deserializeRemovedSubRecord0(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'removedSubRecordUnion': "+ unionIndex9)); + } + } + } + + public void deserializeRemovedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + } + + private void populate_RemovedTypesTestRecord10(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen12 = (decoder.readArrayStart()); + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0) { + for (int counter13 = 0; (counter13 0) { + do { + for (int counter14 = 0; (counter14 0); + } + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + do { + for (int counter15 = 0; (counter15 0); + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/StringableRecord_SpecificDeserializer_842267318_842267318.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/StringableRecord_SpecificDeserializer_842267318_842267318.java new file mode 100644 index 000000000..ea14ef545 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/StringableRecord_SpecificDeserializer_842267318_842267318.java @@ -0,0 +1,255 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class StringableRecord_SpecificDeserializer_842267318_842267318 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public StringableRecord_SpecificDeserializer_842267318_842267318(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserialize(com.linkedin.avro.fastserde.generated.avro.StringableRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeStringableRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserializeStringableRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord; + if ((reuse)!= null) { + StringableRecord = ((com.linkedin.avro.fastserde.generated.avro.StringableRecord)(reuse)); + } else { + StringableRecord = new com.linkedin.avro.fastserde.generated.avro.StringableRecord(); + } + Utf8 charSequence0; + Object oldString0 = StringableRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + StringableRecord.put(0, charSequence0); + populate_StringableRecord0((StringableRecord), (customization), (decoder)); + populate_StringableRecord1((StringableRecord), (customization), (decoder)); + populate_StringableRecord2((StringableRecord), (customization), (decoder)); + populate_StringableRecord3((StringableRecord), (customization), (decoder)); + populate_StringableRecord4((StringableRecord), (customization), (decoder)); + return StringableRecord; + } + + private void populate_StringableRecord0(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = StringableRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + StringableRecord.put(1, charSequence1); + Utf8 charSequence2; + Object oldString2 = StringableRecord.get(2); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + StringableRecord.put(2, charSequence2); + } + + private void populate_StringableRecord1(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence3; + Object oldString3 = StringableRecord.get(3); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + StringableRecord.put(3, charSequence3); + Utf8 charSequence4; + Object oldString4 = StringableRecord.get(4); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + StringableRecord.put(4, charSequence4); + } + + private void populate_StringableRecord2(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List urlArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = StringableRecord.get(5); + if (oldArray0 instanceof List) { + urlArray0 = ((List) oldArray0); + urlArray0 .clear(); + } else { + urlArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 urlMap0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), ((int) chunkLen1))); + } else { + Map urlMapReuse0 = null; + Object oldMap0 = StringableRecord.get(6); + if (oldMap0 instanceof Map) { + urlMapReuse0 = ((Map) oldMap0); + } + if (urlMapReuse0 != (null)) { + urlMapReuse0 .clear(); + urlMap0 = urlMapReuse0; + } else { + urlMap0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), 0)); + } else { + urlMap0 = new HashMap(0); + } + } + StringableRecord.put(6, urlMap0); + } + + private void populate_StringableRecord3(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + StringableRecord.put(7, deserializeStringableSubRecord0(StringableRecord.get(7), (decoder), (customization))); + StringableRecord.put(8, deserializeAnotherSubRecord0(StringableRecord.get(8), (decoder), (customization))); + } + + public com.linkedin.avro.fastserde.generated.avro.StringableSubRecord deserializeStringableSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord; + if ((reuse)!= null) { + StringableSubRecord = ((com.linkedin.avro.fastserde.generated.avro.StringableSubRecord)(reuse)); + } else { + StringableSubRecord = new com.linkedin.avro.fastserde.generated.avro.StringableSubRecord(); + } + Utf8 charSequence7; + Object oldString5 = StringableSubRecord.get(0); + if (oldString5 instanceof Utf8) { + charSequence7 = (decoder).readString(((Utf8) oldString5)); + } else { + charSequence7 = (decoder).readString(null); + } + StringableSubRecord.put(0, charSequence7); + populate_StringableSubRecord0((StringableSubRecord), (customization), (decoder)); + return StringableSubRecord; + } + + private void populate_StringableSubRecord0(com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + StringableSubRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence8; + Object oldString6 = StringableSubRecord.get(1); + if (oldString6 instanceof Utf8) { + charSequence8 = (decoder).readString(((Utf8) oldString6)); + } else { + charSequence8 = (decoder).readString(null); + } + StringableSubRecord.put(1, charSequence8); + } else { + if (unionIndex0 == 2) { + StringableSubRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'nullStringIntUnion': "+ unionIndex0)); + } + } + } + } + + public com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord deserializeAnotherSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord AnotherSubRecord; + if ((reuse)!= null) { + AnotherSubRecord = ((com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord)(reuse)); + } else { + AnotherSubRecord = new com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord(); + } + AnotherSubRecord.put(0, deserializeStringableSubRecord0(AnotherSubRecord.get(0), (decoder), (customization))); + return AnotherSubRecord; + } + + private void populate_StringableRecord4(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + StringableRecord.put(9, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence9; + Object oldString7 = StringableRecord.get(9); + if (oldString7 instanceof Utf8) { + charSequence9 = (decoder).readString(((Utf8) oldString7)); + } else { + charSequence9 = (decoder).readString(null); + } + StringableRecord.put(9, charSequence9); + } else { + throw new RuntimeException(("Illegal union index for 'stringUnion': "+ unionIndex1)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java new file mode 100644 index 000000000..5d05b2bf2 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java @@ -0,0 +1,46 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class TestArrayOfFloats_GenericDeserializer_1408566797_1408566797 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema array_of_float0; + + public TestArrayOfFloats_GenericDeserializer_1408566797_1408566797(Schema readerSchema) { + this.readerSchema = readerSchema; + this.array_of_float0 = readerSchema.getField("array_of_float").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestArrayOfFloats0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestArrayOfFloats0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord TestArrayOfFloats; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + TestArrayOfFloats = ((IndexedRecord)(reuse)); + } else { + TestArrayOfFloats = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + PrimitiveFloatList array_of_float1 = null; + array_of_float1 = ((PrimitiveFloatList) BufferBackedPrimitiveFloatList.readPrimitiveFloatArray(TestArrayOfFloats.get(0), (decoder))); + TestArrayOfFloats.put(0, array_of_float1); + return TestArrayOfFloats; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/TestRecord_GenericDeserializer_473555078_473555078.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/TestRecord_GenericDeserializer_473555078_473555078.java new file mode 100644 index 000000000..576802c40 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/TestRecord_GenericDeserializer_473555078_473555078.java @@ -0,0 +1,78 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_GenericDeserializer_473555078_473555078 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema map_field0; + + public TestRecord_GenericDeserializer_473555078_473555078(Schema readerSchema) { + this.readerSchema = readerSchema; + this.map_field0 = readerSchema.getField("map_field").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord TestRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + TestRecord = ((IndexedRecord)(reuse)); + } else { + TestRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map map_field1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), ((int) chunkLen0))); + } else { + Map map_fieldReuse0 = null; + Object oldMap0 = TestRecord.get(0); + if (oldMap0 instanceof Map) { + map_fieldReuse0 = ((Map) oldMap0); + } + if (map_fieldReuse0 != (null)) { + map_fieldReuse0 .clear(); + map_field1 = map_fieldReuse0; + } else { + map_field1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), 0)); + } else { + map_field1 = new HashMap(0); + } + } + TestRecord.put(0, map_field1); + return TestRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/TestRecord_SpecificDeserializer_1898726132_28900457.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/TestRecord_SpecificDeserializer_1898726132_28900457.java new file mode 100644 index 000000000..604fac5cc --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/TestRecord_SpecificDeserializer_1898726132_28900457.java @@ -0,0 +1,1032 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_1898726132_28900457 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Map enumMappingTestEnum0; + private final Map enumMappingTestEnum1; + private final Map enumMappingTestEnum2; + private final Map enumMappingTestEnum3; + + public TestRecord_SpecificDeserializer_1898726132_28900457(Schema readerSchema) { + this.readerSchema = readerSchema; + HashMap tempEnumMapping0 = new HashMap(5); + tempEnumMapping0 .put(new Integer(0), new Integer(4)); + tempEnumMapping0 .put(new Integer(1), new Integer(3)); + tempEnumMapping0 .put(new Integer(2), new Integer(1)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + HashMap tempEnumMapping1 = new HashMap(5); + tempEnumMapping1 .put(new Integer(0), new Integer(4)); + tempEnumMapping1 .put(new Integer(1), new Integer(3)); + tempEnumMapping1 .put(new Integer(2), new Integer(1)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + HashMap tempEnumMapping2 = new HashMap(5); + tempEnumMapping2 .put(new Integer(0), new Integer(4)); + tempEnumMapping2 .put(new Integer(1), new Integer(3)); + tempEnumMapping2 .put(new Integer(2), new Integer(1)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + HashMap tempEnumMapping3 = new HashMap(5); + tempEnumMapping3 .put(new Integer(0), new Integer(4)); + tempEnumMapping3 .put(new Integer(1), new Integer(3)); + tempEnumMapping3 .put(new Integer(2), new Integer(1)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + TestRecord.put(13, null); + ArrayList defaultArray0 = new ArrayList(); + TestRecord.put(33, defaultArray0); + ArrayList defaultArray1 = new ArrayList(); + TestRecord.put(34, defaultArray1); + ArrayList defaultArray2 = new ArrayList(); + TestRecord.put(35, defaultArray2); + ArrayList defaultArray3 = new ArrayList(); + TestRecord.put(36, defaultArray3); + ArrayList defaultArray4 = new ArrayList(); + TestRecord.put(37, defaultArray4); + ArrayList defaultArray5 = new ArrayList(); + TestRecord.put(38, defaultArray5); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + } else { + if (unionIndex6 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testStringAlias': "+ unionIndex6)); + } + } + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + } else { + if (unionIndex7 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'removedField': "+ unionIndex7)); + } + } + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + } + + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + } + + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex16 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex18)); + } + } + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex22 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex24 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex24)); + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex26 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex26 == 2) { + Utf8 charSequence3; + Object oldString3 = TestRecord.get(32); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + TestRecord.put(32, charSequence3); + } else { + if (unionIndex26 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex26)); + } + } + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/TestRecord_SpecificDeserializer_1991094399_28900457.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/TestRecord_SpecificDeserializer_1991094399_28900457.java new file mode 100644 index 000000000..654482b9b --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/TestRecord_SpecificDeserializer_1991094399_28900457.java @@ -0,0 +1,1036 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_1991094399_28900457 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Map enumMappingTestEnum0; + private final Map enumMappingTestEnum1; + private final Map enumMappingTestEnum2; + private final Map enumMappingTestEnum3; + + public TestRecord_SpecificDeserializer_1991094399_28900457(Schema readerSchema) { + this.readerSchema = readerSchema; + HashMap tempEnumMapping0 = new HashMap(6); + tempEnumMapping0 .put(new Integer(0), new Integer(4)); + tempEnumMapping0 .put(new Integer(1), new Integer(3)); + tempEnumMapping0 .put(new Integer(2), new Integer(1)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(0)); + tempEnumMapping0 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + HashMap tempEnumMapping1 = new HashMap(6); + tempEnumMapping1 .put(new Integer(0), new Integer(4)); + tempEnumMapping1 .put(new Integer(1), new Integer(3)); + tempEnumMapping1 .put(new Integer(2), new Integer(1)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(0)); + tempEnumMapping1 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + HashMap tempEnumMapping2 = new HashMap(6); + tempEnumMapping2 .put(new Integer(0), new Integer(4)); + tempEnumMapping2 .put(new Integer(1), new Integer(3)); + tempEnumMapping2 .put(new Integer(2), new Integer(1)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(0)); + tempEnumMapping2 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + HashMap tempEnumMapping3 = new HashMap(6); + tempEnumMapping3 .put(new Integer(0), new Integer(4)); + tempEnumMapping3 .put(new Integer(1), new Integer(3)); + tempEnumMapping3 .put(new Integer(2), new Integer(1)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(0)); + tempEnumMapping3 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + TestRecord.put(13, null); + ArrayList defaultArray0 = new ArrayList(); + TestRecord.put(33, defaultArray0); + ArrayList defaultArray1 = new ArrayList(); + TestRecord.put(34, defaultArray1); + ArrayList defaultArray2 = new ArrayList(); + TestRecord.put(35, defaultArray2); + ArrayList defaultArray3 = new ArrayList(); + TestRecord.put(36, defaultArray3); + ArrayList defaultArray4 = new ArrayList(); + TestRecord.put(37, defaultArray4); + ArrayList defaultArray5 = new ArrayList(); + TestRecord.put(38, defaultArray5); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + } else { + if (unionIndex6 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testStringAlias': "+ unionIndex6)); + } + } + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + } else { + if (unionIndex7 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'removedField': "+ unionIndex7)); + } + } + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + } + + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + } + + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex16 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex18)); + } + } + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex22 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex24 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex24)); + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex26 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex26 == 2) { + Utf8 charSequence3; + Object oldString3 = TestRecord.get(32); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + TestRecord.put(32, charSequence3); + } else { + if (unionIndex26 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex26)); + } + } + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/TestRecord_SpecificDeserializer_28900457_28900457.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/TestRecord_SpecificDeserializer_28900457_28900457.java new file mode 100644 index 000000000..dcea56ff0 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/TestRecord_SpecificDeserializer_28900457_28900457.java @@ -0,0 +1,1040 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_28900457_28900457 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public TestRecord_SpecificDeserializer_28900457_28900457(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex7 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex7)); + } + } + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen16 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 stringArray0 = null; + long chunkLen20 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen20)); + } + while (chunkLen20 > 0) { + for (int counter20 = 0; (counter20 +{ + + private final Schema readerSchema; + private final Schema recordRecordSchema0; + + public UNION_GenericDeserializer_1971822364_1672473580(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordRecordSchema0 = readerSchema.getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordRecordSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(recordRecordSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/UNION_GenericDeserializer_2018567528_1606337179.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/UNION_GenericDeserializer_2018567528_1606337179.java new file mode 100644 index 000000000..05b0d826a --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/UNION_GenericDeserializer_2018567528_1606337179.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class UNION_GenericDeserializer_2018567528_1606337179 + implements FastDeserializer> +{ + + private final Schema readerSchema; + private final Schema arrayArraySchema0; + private final Schema arrayArrayElemSchema0; + + public UNION_GenericDeserializer_2018567528_1606337179(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArraySchema0 = readerSchema.getTypes().get(1); + this.arrayArrayElemSchema0 = arrayArraySchema0 .getElementType(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), arrayArraySchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + private final Schema mapMapSchema0; + private final Schema mapMapValueSchema0; + + public UNION_GenericDeserializer_568621313_1223705675(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapSchema0 = readerSchema.getTypes().get(1); + this.mapMapValueSchema0 = mapMapSchema0 .getValueType(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapMapValueSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java new file mode 100644 index 000000000..fe24b6b3b --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.MyEnumV1; +import com.linkedin.avro.fastserde.generated.avro.MyEnumV2; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserialize(com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeUnionOfRecordsWithSameNameEnumField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserializeUnionOfRecordsWithSameNameEnumField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField UnionOfRecordsWithSameNameEnumField; + if ((reuse)!= null) { + UnionOfRecordsWithSameNameEnumField = ((com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField)(reuse)); + } else { + UnionOfRecordsWithSameNameEnumField = new com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV10(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV20(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + return UnionOfRecordsWithSameNameEnumField; + } + + public com.linkedin.avro.fastserde.generated.avro.MyRecordV1 deserializeMyRecordV10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.MyRecordV1 MyRecordV1; + if ((reuse)!= null) { + MyRecordV1 = ((com.linkedin.avro.fastserde.generated.avro.MyRecordV1)(reuse)); + } else { + MyRecordV1 = new com.linkedin.avro.fastserde.generated.avro.MyRecordV1(); + } + MyRecordV1 .put(0, Enums.getConstant(MyEnumV1 .class, (decoder.readEnum()))); + return MyRecordV1; + } + + public com.linkedin.avro.fastserde.generated.avro.MyRecordV2 deserializeMyRecordV20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.MyRecordV2 MyRecordV2; + if ((reuse)!= null) { + MyRecordV2 = ((com.linkedin.avro.fastserde.generated.avro.MyRecordV2)(reuse)); + } else { + MyRecordV2 = new com.linkedin.avro.fastserde.generated.avro.MyRecordV2(); + } + MyRecordV2 .put(0, Enums.getConstant(MyEnumV2 .class, (decoder.readEnum()))); + return MyRecordV2; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/recordName_GenericDeserializer_1743054079_1743054079.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/recordName_GenericDeserializer_1743054079_1743054079.java new file mode 100644 index 000000000..ea1db6b68 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/recordName_GenericDeserializer_1743054079_1743054079.java @@ -0,0 +1,67 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class recordName_GenericDeserializer_1743054079_1743054079 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema unionField0; + + public recordName_GenericDeserializer_1743054079_1743054079(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionField0 = readerSchema.getField("unionField").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecordName0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecordName0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord recordName; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + recordName = ((IndexedRecord)(reuse)); + } else { + recordName = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = recordName.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + recordName.put(0, charSequence0); + populate_recordName0((recordName), (customization), (decoder)); + return recordName; + } + + private void populate_recordName0(IndexedRecord recordName, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + recordName.put(1, null); + } else { + if (unionIndex0 == 1) { + recordName.put(1, deserializerecordName0(recordName.get(1), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1025741720_1557256887.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1025741720_1557256887.java new file mode 100644 index 000000000..544f762bf --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1025741720_1557256887.java @@ -0,0 +1,96 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1025741720_1557256887 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_1025741720_1557256887(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + Map someIntsOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } + } + record.put(0, someIntsOption0); + } else { + throw new RuntimeException(("Illegal union index for 'someInts': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1126840752_2099305627.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1126840752_2099305627.java new file mode 100644 index 000000000..45768f7cc --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1126840752_2099305627.java @@ -0,0 +1,50 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1126840752_2099305627 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1126840752_2099305627(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + record.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 1) { + throw new AvroTypeException("Found \"string\", expecting \"int\""); + } else { + throw new RuntimeException(("Illegal union index for 'someField': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1191367445_653449771.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1191367445_653449771.java new file mode 100644 index 000000000..dbfbf1730 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1191367445_653449771.java @@ -0,0 +1,69 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1191367445_653449771 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_1191367445_653449771(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList someIntsOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someIntsOption0 = ((PrimitiveIntList) oldArray0); + someIntsOption0 .clear(); + } else { + someIntsOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1373882843_1971822364(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + record.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'someInt': "+ unionIndex0)); + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1556659421_711533897.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1556659421_711533897.java new file mode 100644 index 000000000..53cd8133d --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1556659421_711533897.java @@ -0,0 +1,72 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1556659421_711533897 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema subRecord0; + + public record_GenericDeserializer_1556659421_711533897(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"subRecord\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"fields\":[{\"name\":\"someInt1\",\"type\":\"int\",\"doc\":\"\"},{\"name\":\"someInt2\",\"type\":\"int\",\"doc\":\"\"}]}"); + } else { + if (unionIndex0 == 1) { + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex0)); + } + } + return record; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord0); + } + subRecord.put(0, (decoder.readInt())); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + subRecord.put(1, (decoder.readInt())); + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1557256887_1025741720.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1557256887_1025741720.java new file mode 100644 index 000000000..226e32cb7 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1557256887_1025741720.java @@ -0,0 +1,81 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1557256887_1025741720 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsMapSchema0; + private final Schema someIntsMapValueSchema0; + + public record_GenericDeserializer_1557256887_1025741720(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsMapSchema0 = someInts0 .getTypes().get(1); + this.someIntsMapValueSchema0 = someIntsMapSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map someInts1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } + } + record.put(0, someInts1); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1557256887_753570467.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1557256887_753570467.java new file mode 100644 index 000000000..ae2e29a2a --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1557256887_753570467.java @@ -0,0 +1,79 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1557256887_753570467 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsMapSchema0; + + public record_GenericDeserializer_1557256887_753570467(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsMapSchema0 = someInts0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map someInts1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } + } + record.put(0, someInts1); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1672473580_1971822364.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1672473580_1971822364.java new file mode 100644 index 000000000..5690fb8cf --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1672473580_1971822364.java @@ -0,0 +1,50 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1672473580_1971822364 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1672473580_1971822364(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}"); + } else { + if (unionIndex0 == 1) { + return deserializerecord0((reuse), (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1971822364_1373882843.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1971822364_1373882843.java new file mode 100644 index 000000000..74ed534c2 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_1971822364_1373882843.java @@ -0,0 +1,42 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1971822364_1373882843 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInt0; + + public record_GenericDeserializer_1971822364_1373882843(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInt0 = readerSchema.getField("someInt").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_653449771_1191367445.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_653449771_1191367445.java new file mode 100644 index 000000000..5a60fc65e --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_653449771_1191367445.java @@ -0,0 +1,61 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_653449771_1191367445 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsArraySchema0; + + public record_GenericDeserializer_653449771_1191367445(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsArraySchema0 = someInts0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + PrimitiveIntList someInts1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someInts1 = ((PrimitiveIntList) oldArray0); + someInts1 .clear(); + } else { + someInts1 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsArraySchema0; + private final Schema someIntsArrayElemSchema0; + + public record_GenericDeserializer_653449771_813379571(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsArraySchema0 = someInts0 .getTypes().get(1); + this.someIntsArrayElemSchema0 = someIntsArraySchema0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List someInts1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof List) { + someInts1 = ((List) oldArray0); + someInts1 .clear(); + } else { + someInts1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), someIntsArraySchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema subRecord0; + private final Schema subRecordRecordSchema0; + + public record_GenericDeserializer_711533897_1556659421(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + this.subRecordRecordSchema0 = subRecord0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); + return record; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecordRecordSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecordRecordSchema0); + } + subRecord.put(0, (decoder.readInt())); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + subRecord.put(1, (decoder.readInt())); + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_753570467_1557256887.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_753570467_1557256887.java new file mode 100644 index 000000000..beb208efe --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_753570467_1557256887.java @@ -0,0 +1,87 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_753570467_1557256887 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_753570467_1557256887(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + Map someIntsOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } + } + record.put(0, someIntsOption0); + } else { + throw new RuntimeException(("Illegal union index for 'someInts': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_813379571_653449771.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_813379571_653449771.java new file mode 100644 index 000000000..0dd9c84df --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_4/record_GenericDeserializer_813379571_653449771.java @@ -0,0 +1,83 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_813379571_653449771 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_813379571_653449771(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList someIntsOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someIntsOption0 = ((PrimitiveIntList) oldArray0); + someIntsOption0 .clear(); + } else { + someIntsOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + + public testRecord_GenericDeserializer_1146484089_1256982207(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(3); + tempEnumMapping0 .put(new Integer(0), new Integer(0)); + tempEnumMapping0 .put(new Integer(1), new Integer(1)); + tempEnumMapping0 .put(new Integer(2), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.testEnum: No match for C")); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializetestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializetestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord testRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + testRecord = ((IndexedRecord)(reuse)); + } else { + testRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + testRecord.put(0, enumValue0); + return testRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/Array_of_BOOLEAN_GenericSerializer_869749973.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/Array_of_BOOLEAN_GenericSerializer_869749973.java new file mode 100644 index 000000000..90a276a2d --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/Array_of_BOOLEAN_GenericSerializer_869749973.java @@ -0,0 +1,41 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.io.Encoder; + +public class Array_of_BOOLEAN_GenericSerializer_869749973 + implements FastSerializer> +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveBooleanList) { + PrimitiveBooleanList primitiveList0 = ((PrimitiveBooleanList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveDoubleList) { + PrimitiveDoubleList primitiveList0 = ((PrimitiveDoubleList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveFloatList) { + PrimitiveFloatList primitiveList0 = ((PrimitiveFloatList) array0); + if (primitiveList0 instanceof BufferBackedPrimitiveFloatList) { + BufferBackedPrimitiveFloatList bufferBackedPrimitiveFloatList = ((BufferBackedPrimitiveFloatList) primitiveList0); + bufferBackedPrimitiveFloatList.writeFloats((encoder)); + } else { + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList0 = ((PrimitiveIntList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveLongList) { + PrimitiveLongList primitiveList0 = ((PrimitiveLongList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (int counter0 = 0; (counter0 ) data).get(counter0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/Array_of_record_GenericSerializer_477614132.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/Array_of_record_GenericSerializer_477614132.java new file mode 100644 index 000000000..28759ebc3 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/Array_of_record_GenericSerializer_477614132.java @@ -0,0 +1,53 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Array_of_record_GenericSerializer_477614132 + implements FastSerializer> +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (int counter0 = 0; (counter0 ) data).get(counter0); + serializeRecord0(record0, (encoder), (customization)); + } + } + (encoder).writeArrayEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java new file mode 100644 index 000000000..edcddeea2 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java @@ -0,0 +1,4527 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(1))); + (encoder).writeInt(((Integer) data.get(2))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(3))); + (encoder).writeInt(((Integer) data.get(4))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(5))); + (encoder).writeInt(((Integer) data.get(6))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(7))); + (encoder).writeInt(((Integer) data.get(8))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(9))); + (encoder).writeInt(((Integer) data.get(10))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(11))); + (encoder).writeInt(((Integer) data.get(12))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(13))); + (encoder).writeInt(((Integer) data.get(14))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(15))); + (encoder).writeInt(((Integer) data.get(16))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(17))); + (encoder).writeInt(((Integer) data.get(18))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(19))); + (encoder).writeInt(((Integer) data.get(20))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(21))); + (encoder).writeInt(((Integer) data.get(22))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(23))); + (encoder).writeInt(((Integer) data.get(24))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(25))); + (encoder).writeInt(((Integer) data.get(26))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(27))); + (encoder).writeInt(((Integer) data.get(28))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(29))); + (encoder).writeInt(((Integer) data.get(30))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(31))); + (encoder).writeInt(((Integer) data.get(32))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(33))); + (encoder).writeInt(((Integer) data.get(34))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(35))); + (encoder).writeInt(((Integer) data.get(36))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(37))); + (encoder).writeInt(((Integer) data.get(38))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(39))); + (encoder).writeInt(((Integer) data.get(40))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(41))); + (encoder).writeInt(((Integer) data.get(42))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(43))); + (encoder).writeInt(((Integer) data.get(44))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(45))); + (encoder).writeInt(((Integer) data.get(46))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(47))); + (encoder).writeInt(((Integer) data.get(48))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(49))); + (encoder).writeInt(((Integer) data.get(50))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(51))); + (encoder).writeInt(((Integer) data.get(52))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(53))); + (encoder).writeInt(((Integer) data.get(54))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(55))); + (encoder).writeInt(((Integer) data.get(56))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(57))); + (encoder).writeInt(((Integer) data.get(58))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(59))); + (encoder).writeInt(((Integer) data.get(60))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(61))); + (encoder).writeInt(((Integer) data.get(62))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(63))); + (encoder).writeInt(((Integer) data.get(64))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(65))); + (encoder).writeInt(((Integer) data.get(66))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(67))); + (encoder).writeInt(((Integer) data.get(68))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(69))); + (encoder).writeInt(((Integer) data.get(70))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(71))); + (encoder).writeInt(((Integer) data.get(72))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(73))); + (encoder).writeInt(((Integer) data.get(74))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(75))); + (encoder).writeInt(((Integer) data.get(76))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(77))); + (encoder).writeInt(((Integer) data.get(78))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(79))); + (encoder).writeInt(((Integer) data.get(80))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(81))); + (encoder).writeInt(((Integer) data.get(82))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(83))); + (encoder).writeInt(((Integer) data.get(84))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(85))); + (encoder).writeInt(((Integer) data.get(86))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(87))); + (encoder).writeInt(((Integer) data.get(88))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(89))); + (encoder).writeInt(((Integer) data.get(90))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(91))); + (encoder).writeInt(((Integer) data.get(92))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(93))); + (encoder).writeInt(((Integer) data.get(94))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(95))); + (encoder).writeInt(((Integer) data.get(96))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(97))); + (encoder).writeInt(((Integer) data.get(98))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(99))); + (encoder).writeInt(((Integer) data.get(100))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(101))); + (encoder).writeInt(((Integer) data.get(102))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(103))); + (encoder).writeInt(((Integer) data.get(104))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(105))); + (encoder).writeInt(((Integer) data.get(106))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(107))); + (encoder).writeInt(((Integer) data.get(108))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(109))); + (encoder).writeInt(((Integer) data.get(110))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(111))); + (encoder).writeInt(((Integer) data.get(112))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(113))); + (encoder).writeInt(((Integer) data.get(114))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(115))); + (encoder).writeInt(((Integer) data.get(116))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(117))); + (encoder).writeInt(((Integer) data.get(118))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(119))); + (encoder).writeInt(((Integer) data.get(120))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(121))); + (encoder).writeInt(((Integer) data.get(122))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(123))); + (encoder).writeInt(((Integer) data.get(124))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(125))); + (encoder).writeInt(((Integer) data.get(126))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(127))); + (encoder).writeInt(((Integer) data.get(128))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(129))); + (encoder).writeInt(((Integer) data.get(130))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(131))); + (encoder).writeInt(((Integer) data.get(132))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(133))); + (encoder).writeInt(((Integer) data.get(134))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(135))); + (encoder).writeInt(((Integer) data.get(136))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(137))); + (encoder).writeInt(((Integer) data.get(138))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(139))); + (encoder).writeInt(((Integer) data.get(140))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(141))); + (encoder).writeInt(((Integer) data.get(142))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(143))); + (encoder).writeInt(((Integer) data.get(144))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(145))); + (encoder).writeInt(((Integer) data.get(146))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(147))); + (encoder).writeInt(((Integer) data.get(148))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(149))); + (encoder).writeInt(((Integer) data.get(150))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(151))); + (encoder).writeInt(((Integer) data.get(152))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(153))); + (encoder).writeInt(((Integer) data.get(154))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(155))); + (encoder).writeInt(((Integer) data.get(156))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(157))); + (encoder).writeInt(((Integer) data.get(158))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(159))); + (encoder).writeInt(((Integer) data.get(160))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(161))); + (encoder).writeInt(((Integer) data.get(162))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(163))); + (encoder).writeInt(((Integer) data.get(164))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(165))); + (encoder).writeInt(((Integer) data.get(166))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(167))); + (encoder).writeInt(((Integer) data.get(168))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(169))); + (encoder).writeInt(((Integer) data.get(170))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(171))); + (encoder).writeInt(((Integer) data.get(172))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(173))); + (encoder).writeInt(((Integer) data.get(174))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(175))); + (encoder).writeInt(((Integer) data.get(176))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(177))); + (encoder).writeInt(((Integer) data.get(178))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(179))); + (encoder).writeInt(((Integer) data.get(180))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(181))); + (encoder).writeInt(((Integer) data.get(182))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(183))); + (encoder).writeInt(((Integer) data.get(184))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(185))); + (encoder).writeInt(((Integer) data.get(186))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(187))); + (encoder).writeInt(((Integer) data.get(188))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(189))); + (encoder).writeInt(((Integer) data.get(190))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(191))); + (encoder).writeInt(((Integer) data.get(192))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(193))); + (encoder).writeInt(((Integer) data.get(194))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(195))); + (encoder).writeInt(((Integer) data.get(196))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(197))); + (encoder).writeInt(((Integer) data.get(198))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(199))); + (encoder).writeInt(((Integer) data.get(200))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(201))); + (encoder).writeInt(((Integer) data.get(202))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(203))); + (encoder).writeInt(((Integer) data.get(204))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(205))); + (encoder).writeInt(((Integer) data.get(206))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(207))); + (encoder).writeInt(((Integer) data.get(208))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(209))); + (encoder).writeInt(((Integer) data.get(210))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(211))); + (encoder).writeInt(((Integer) data.get(212))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(213))); + (encoder).writeInt(((Integer) data.get(214))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(215))); + (encoder).writeInt(((Integer) data.get(216))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(217))); + (encoder).writeInt(((Integer) data.get(218))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(219))); + (encoder).writeInt(((Integer) data.get(220))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(221))); + (encoder).writeInt(((Integer) data.get(222))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(223))); + (encoder).writeInt(((Integer) data.get(224))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(225))); + (encoder).writeInt(((Integer) data.get(226))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(227))); + (encoder).writeInt(((Integer) data.get(228))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(229))); + (encoder).writeInt(((Integer) data.get(230))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(231))); + (encoder).writeInt(((Integer) data.get(232))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(233))); + (encoder).writeInt(((Integer) data.get(234))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(235))); + (encoder).writeInt(((Integer) data.get(236))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(237))); + (encoder).writeInt(((Integer) data.get(238))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(239))); + (encoder).writeInt(((Integer) data.get(240))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(241))); + (encoder).writeInt(((Integer) data.get(242))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(243))); + (encoder).writeInt(((Integer) data.get(244))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(245))); + (encoder).writeInt(((Integer) data.get(246))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(247))); + (encoder).writeInt(((Integer) data.get(248))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(249))); + (encoder).writeInt(((Integer) data.get(250))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(251))); + (encoder).writeInt(((Integer) data.get(252))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(253))); + (encoder).writeInt(((Integer) data.get(254))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(255))); + (encoder).writeInt(((Integer) data.get(256))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(257))); + (encoder).writeInt(((Integer) data.get(258))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(259))); + (encoder).writeInt(((Integer) data.get(260))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(261))); + (encoder).writeInt(((Integer) data.get(262))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(263))); + (encoder).writeInt(((Integer) data.get(264))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(265))); + (encoder).writeInt(((Integer) data.get(266))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(267))); + (encoder).writeInt(((Integer) data.get(268))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(269))); + (encoder).writeInt(((Integer) data.get(270))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(271))); + (encoder).writeInt(((Integer) data.get(272))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(273))); + (encoder).writeInt(((Integer) data.get(274))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(275))); + (encoder).writeInt(((Integer) data.get(276))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(277))); + (encoder).writeInt(((Integer) data.get(278))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(279))); + (encoder).writeInt(((Integer) data.get(280))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(281))); + (encoder).writeInt(((Integer) data.get(282))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(283))); + (encoder).writeInt(((Integer) data.get(284))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(285))); + (encoder).writeInt(((Integer) data.get(286))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(287))); + (encoder).writeInt(((Integer) data.get(288))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(289))); + (encoder).writeInt(((Integer) data.get(290))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(291))); + (encoder).writeInt(((Integer) data.get(292))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(293))); + (encoder).writeInt(((Integer) data.get(294))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(295))); + (encoder).writeInt(((Integer) data.get(296))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(297))); + (encoder).writeInt(((Integer) data.get(298))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(299))); + (encoder).writeInt(((Integer) data.get(300))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(301))); + (encoder).writeInt(((Integer) data.get(302))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(303))); + (encoder).writeInt(((Integer) data.get(304))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(305))); + (encoder).writeInt(((Integer) data.get(306))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(307))); + (encoder).writeInt(((Integer) data.get(308))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(309))); + (encoder).writeInt(((Integer) data.get(310))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(311))); + (encoder).writeInt(((Integer) data.get(312))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(313))); + (encoder).writeInt(((Integer) data.get(314))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(315))); + (encoder).writeInt(((Integer) data.get(316))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(317))); + (encoder).writeInt(((Integer) data.get(318))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(319))); + (encoder).writeInt(((Integer) data.get(320))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(321))); + (encoder).writeInt(((Integer) data.get(322))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(323))); + (encoder).writeInt(((Integer) data.get(324))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(325))); + (encoder).writeInt(((Integer) data.get(326))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(327))); + (encoder).writeInt(((Integer) data.get(328))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(329))); + (encoder).writeInt(((Integer) data.get(330))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(331))); + (encoder).writeInt(((Integer) data.get(332))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(333))); + (encoder).writeInt(((Integer) data.get(334))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(335))); + (encoder).writeInt(((Integer) data.get(336))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(337))); + (encoder).writeInt(((Integer) data.get(338))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(339))); + (encoder).writeInt(((Integer) data.get(340))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(341))); + (encoder).writeInt(((Integer) data.get(342))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(343))); + (encoder).writeInt(((Integer) data.get(344))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(345))); + (encoder).writeInt(((Integer) data.get(346))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(347))); + (encoder).writeInt(((Integer) data.get(348))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(349))); + (encoder).writeInt(((Integer) data.get(350))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(351))); + (encoder).writeInt(((Integer) data.get(352))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(353))); + (encoder).writeInt(((Integer) data.get(354))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(355))); + (encoder).writeInt(((Integer) data.get(356))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(357))); + (encoder).writeInt(((Integer) data.get(358))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(359))); + (encoder).writeInt(((Integer) data.get(360))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(361))); + (encoder).writeInt(((Integer) data.get(362))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(363))); + (encoder).writeInt(((Integer) data.get(364))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(365))); + (encoder).writeInt(((Integer) data.get(366))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(367))); + (encoder).writeInt(((Integer) data.get(368))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(369))); + (encoder).writeInt(((Integer) data.get(370))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(371))); + (encoder).writeInt(((Integer) data.get(372))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(373))); + (encoder).writeInt(((Integer) data.get(374))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(375))); + (encoder).writeInt(((Integer) data.get(376))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(377))); + (encoder).writeInt(((Integer) data.get(378))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(379))); + (encoder).writeInt(((Integer) data.get(380))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(381))); + (encoder).writeInt(((Integer) data.get(382))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(383))); + (encoder).writeInt(((Integer) data.get(384))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(385))); + (encoder).writeInt(((Integer) data.get(386))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(387))); + (encoder).writeInt(((Integer) data.get(388))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(389))); + (encoder).writeInt(((Integer) data.get(390))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(391))); + (encoder).writeInt(((Integer) data.get(392))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(393))); + (encoder).writeInt(((Integer) data.get(394))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(395))); + (encoder).writeInt(((Integer) data.get(396))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(397))); + (encoder).writeInt(((Integer) data.get(398))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(399))); + (encoder).writeInt(((Integer) data.get(400))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(401))); + (encoder).writeInt(((Integer) data.get(402))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(403))); + (encoder).writeInt(((Integer) data.get(404))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(405))); + (encoder).writeInt(((Integer) data.get(406))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(407))); + (encoder).writeInt(((Integer) data.get(408))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(409))); + (encoder).writeInt(((Integer) data.get(410))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(411))); + (encoder).writeInt(((Integer) data.get(412))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(413))); + (encoder).writeInt(((Integer) data.get(414))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(415))); + (encoder).writeInt(((Integer) data.get(416))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(417))); + (encoder).writeInt(((Integer) data.get(418))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(419))); + (encoder).writeInt(((Integer) data.get(420))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(421))); + (encoder).writeInt(((Integer) data.get(422))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(423))); + (encoder).writeInt(((Integer) data.get(424))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(425))); + (encoder).writeInt(((Integer) data.get(426))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(427))); + (encoder).writeInt(((Integer) data.get(428))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(429))); + (encoder).writeInt(((Integer) data.get(430))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(431))); + (encoder).writeInt(((Integer) data.get(432))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(433))); + (encoder).writeInt(((Integer) data.get(434))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(435))); + (encoder).writeInt(((Integer) data.get(436))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(437))); + (encoder).writeInt(((Integer) data.get(438))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(439))); + (encoder).writeInt(((Integer) data.get(440))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(441))); + (encoder).writeInt(((Integer) data.get(442))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(443))); + (encoder).writeInt(((Integer) data.get(444))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(445))); + (encoder).writeInt(((Integer) data.get(446))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(447))); + (encoder).writeInt(((Integer) data.get(448))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(449))); + (encoder).writeInt(((Integer) data.get(450))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(451))); + (encoder).writeInt(((Integer) data.get(452))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(453))); + (encoder).writeInt(((Integer) data.get(454))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(455))); + (encoder).writeInt(((Integer) data.get(456))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(457))); + (encoder).writeInt(((Integer) data.get(458))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(459))); + (encoder).writeInt(((Integer) data.get(460))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(461))); + (encoder).writeInt(((Integer) data.get(462))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(463))); + (encoder).writeInt(((Integer) data.get(464))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(465))); + (encoder).writeInt(((Integer) data.get(466))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(467))); + (encoder).writeInt(((Integer) data.get(468))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(469))); + (encoder).writeInt(((Integer) data.get(470))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(471))); + (encoder).writeInt(((Integer) data.get(472))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(473))); + (encoder).writeInt(((Integer) data.get(474))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(475))); + (encoder).writeInt(((Integer) data.get(476))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(477))); + (encoder).writeInt(((Integer) data.get(478))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(479))); + (encoder).writeInt(((Integer) data.get(480))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(481))); + (encoder).writeInt(((Integer) data.get(482))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(483))); + (encoder).writeInt(((Integer) data.get(484))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(485))); + (encoder).writeInt(((Integer) data.get(486))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(487))); + (encoder).writeInt(((Integer) data.get(488))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(489))); + (encoder).writeInt(((Integer) data.get(490))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(491))); + (encoder).writeInt(((Integer) data.get(492))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(493))); + (encoder).writeInt(((Integer) data.get(494))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(495))); + (encoder).writeInt(((Integer) data.get(496))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(497))); + (encoder).writeInt(((Integer) data.get(498))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(499))); + (encoder).writeInt(((Integer) data.get(500))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(501))); + (encoder).writeInt(((Integer) data.get(502))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(503))); + (encoder).writeInt(((Integer) data.get(504))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(505))); + (encoder).writeInt(((Integer) data.get(506))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(507))); + (encoder).writeInt(((Integer) data.get(508))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(509))); + (encoder).writeInt(((Integer) data.get(510))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(511))); + (encoder).writeInt(((Integer) data.get(512))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(513))); + (encoder).writeInt(((Integer) data.get(514))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(515))); + (encoder).writeInt(((Integer) data.get(516))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(517))); + (encoder).writeInt(((Integer) data.get(518))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(519))); + (encoder).writeInt(((Integer) data.get(520))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(521))); + (encoder).writeInt(((Integer) data.get(522))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(523))); + (encoder).writeInt(((Integer) data.get(524))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(525))); + (encoder).writeInt(((Integer) data.get(526))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(527))); + (encoder).writeInt(((Integer) data.get(528))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(529))); + (encoder).writeInt(((Integer) data.get(530))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(531))); + (encoder).writeInt(((Integer) data.get(532))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(533))); + (encoder).writeInt(((Integer) data.get(534))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(535))); + (encoder).writeInt(((Integer) data.get(536))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(537))); + (encoder).writeInt(((Integer) data.get(538))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(539))); + (encoder).writeInt(((Integer) data.get(540))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(541))); + (encoder).writeInt(((Integer) data.get(542))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(543))); + (encoder).writeInt(((Integer) data.get(544))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(545))); + (encoder).writeInt(((Integer) data.get(546))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(547))); + (encoder).writeInt(((Integer) data.get(548))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(549))); + (encoder).writeInt(((Integer) data.get(550))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(551))); + (encoder).writeInt(((Integer) data.get(552))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(553))); + (encoder).writeInt(((Integer) data.get(554))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(555))); + (encoder).writeInt(((Integer) data.get(556))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(557))); + (encoder).writeInt(((Integer) data.get(558))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(559))); + (encoder).writeInt(((Integer) data.get(560))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(561))); + (encoder).writeInt(((Integer) data.get(562))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(563))); + (encoder).writeInt(((Integer) data.get(564))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(565))); + (encoder).writeInt(((Integer) data.get(566))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(567))); + (encoder).writeInt(((Integer) data.get(568))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(569))); + (encoder).writeInt(((Integer) data.get(570))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(571))); + (encoder).writeInt(((Integer) data.get(572))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(573))); + (encoder).writeInt(((Integer) data.get(574))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(575))); + (encoder).writeInt(((Integer) data.get(576))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(577))); + (encoder).writeInt(((Integer) data.get(578))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(579))); + (encoder).writeInt(((Integer) data.get(580))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(581))); + (encoder).writeInt(((Integer) data.get(582))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(583))); + (encoder).writeInt(((Integer) data.get(584))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(585))); + (encoder).writeInt(((Integer) data.get(586))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(587))); + (encoder).writeInt(((Integer) data.get(588))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(589))); + (encoder).writeInt(((Integer) data.get(590))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(591))); + (encoder).writeInt(((Integer) data.get(592))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(593))); + (encoder).writeInt(((Integer) data.get(594))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(595))); + (encoder).writeInt(((Integer) data.get(596))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(597))); + (encoder).writeInt(((Integer) data.get(598))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(599))); + (encoder).writeInt(((Integer) data.get(600))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(601))); + (encoder).writeInt(((Integer) data.get(602))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(603))); + (encoder).writeInt(((Integer) data.get(604))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(605))); + (encoder).writeInt(((Integer) data.get(606))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(607))); + (encoder).writeInt(((Integer) data.get(608))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(609))); + (encoder).writeInt(((Integer) data.get(610))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(611))); + (encoder).writeInt(((Integer) data.get(612))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(613))); + (encoder).writeInt(((Integer) data.get(614))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(615))); + (encoder).writeInt(((Integer) data.get(616))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(617))); + (encoder).writeInt(((Integer) data.get(618))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(619))); + (encoder).writeInt(((Integer) data.get(620))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(621))); + (encoder).writeInt(((Integer) data.get(622))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(623))); + (encoder).writeInt(((Integer) data.get(624))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(625))); + (encoder).writeInt(((Integer) data.get(626))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(627))); + (encoder).writeInt(((Integer) data.get(628))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(629))); + (encoder).writeInt(((Integer) data.get(630))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(631))); + (encoder).writeInt(((Integer) data.get(632))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(633))); + (encoder).writeInt(((Integer) data.get(634))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(635))); + (encoder).writeInt(((Integer) data.get(636))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(637))); + (encoder).writeInt(((Integer) data.get(638))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(639))); + (encoder).writeInt(((Integer) data.get(640))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(641))); + (encoder).writeInt(((Integer) data.get(642))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(643))); + (encoder).writeInt(((Integer) data.get(644))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(645))); + (encoder).writeInt(((Integer) data.get(646))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(647))); + (encoder).writeInt(((Integer) data.get(648))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(649))); + (encoder).writeInt(((Integer) data.get(650))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(651))); + (encoder).writeInt(((Integer) data.get(652))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(653))); + (encoder).writeInt(((Integer) data.get(654))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(655))); + (encoder).writeInt(((Integer) data.get(656))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(657))); + (encoder).writeInt(((Integer) data.get(658))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(659))); + (encoder).writeInt(((Integer) data.get(660))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(661))); + (encoder).writeInt(((Integer) data.get(662))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(663))); + (encoder).writeInt(((Integer) data.get(664))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(665))); + (encoder).writeInt(((Integer) data.get(666))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(667))); + (encoder).writeInt(((Integer) data.get(668))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(669))); + (encoder).writeInt(((Integer) data.get(670))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(671))); + (encoder).writeInt(((Integer) data.get(672))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(673))); + (encoder).writeInt(((Integer) data.get(674))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(675))); + (encoder).writeInt(((Integer) data.get(676))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(677))); + (encoder).writeInt(((Integer) data.get(678))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(679))); + (encoder).writeInt(((Integer) data.get(680))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(681))); + (encoder).writeInt(((Integer) data.get(682))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(683))); + (encoder).writeInt(((Integer) data.get(684))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(685))); + (encoder).writeInt(((Integer) data.get(686))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(687))); + (encoder).writeInt(((Integer) data.get(688))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(689))); + (encoder).writeInt(((Integer) data.get(690))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(691))); + (encoder).writeInt(((Integer) data.get(692))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(693))); + (encoder).writeInt(((Integer) data.get(694))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(695))); + (encoder).writeInt(((Integer) data.get(696))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(697))); + (encoder).writeInt(((Integer) data.get(698))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(699))); + (encoder).writeInt(((Integer) data.get(700))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(701))); + (encoder).writeInt(((Integer) data.get(702))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(703))); + (encoder).writeInt(((Integer) data.get(704))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(705))); + (encoder).writeInt(((Integer) data.get(706))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(707))); + (encoder).writeInt(((Integer) data.get(708))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(709))); + (encoder).writeInt(((Integer) data.get(710))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(711))); + (encoder).writeInt(((Integer) data.get(712))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(713))); + (encoder).writeInt(((Integer) data.get(714))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(715))); + (encoder).writeInt(((Integer) data.get(716))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(717))); + (encoder).writeInt(((Integer) data.get(718))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(719))); + (encoder).writeInt(((Integer) data.get(720))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(721))); + (encoder).writeInt(((Integer) data.get(722))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(723))); + (encoder).writeInt(((Integer) data.get(724))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(725))); + (encoder).writeInt(((Integer) data.get(726))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(727))); + (encoder).writeInt(((Integer) data.get(728))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(729))); + (encoder).writeInt(((Integer) data.get(730))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(731))); + (encoder).writeInt(((Integer) data.get(732))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(733))); + (encoder).writeInt(((Integer) data.get(734))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(735))); + (encoder).writeInt(((Integer) data.get(736))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(737))); + (encoder).writeInt(((Integer) data.get(738))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(739))); + (encoder).writeInt(((Integer) data.get(740))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(741))); + (encoder).writeInt(((Integer) data.get(742))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(743))); + (encoder).writeInt(((Integer) data.get(744))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(745))); + (encoder).writeInt(((Integer) data.get(746))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(747))); + (encoder).writeInt(((Integer) data.get(748))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(749))); + (encoder).writeInt(((Integer) data.get(750))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(751))); + (encoder).writeInt(((Integer) data.get(752))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(753))); + (encoder).writeInt(((Integer) data.get(754))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(755))); + (encoder).writeInt(((Integer) data.get(756))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(757))); + (encoder).writeInt(((Integer) data.get(758))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(759))); + (encoder).writeInt(((Integer) data.get(760))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(761))); + (encoder).writeInt(((Integer) data.get(762))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(763))); + (encoder).writeInt(((Integer) data.get(764))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(765))); + (encoder).writeInt(((Integer) data.get(766))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(767))); + (encoder).writeInt(((Integer) data.get(768))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(769))); + (encoder).writeInt(((Integer) data.get(770))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(771))); + (encoder).writeInt(((Integer) data.get(772))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(773))); + (encoder).writeInt(((Integer) data.get(774))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(775))); + (encoder).writeInt(((Integer) data.get(776))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(777))); + (encoder).writeInt(((Integer) data.get(778))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(779))); + (encoder).writeInt(((Integer) data.get(780))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(781))); + (encoder).writeInt(((Integer) data.get(782))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(783))); + (encoder).writeInt(((Integer) data.get(784))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(785))); + (encoder).writeInt(((Integer) data.get(786))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(787))); + (encoder).writeInt(((Integer) data.get(788))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(789))); + (encoder).writeInt(((Integer) data.get(790))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(791))); + (encoder).writeInt(((Integer) data.get(792))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(793))); + (encoder).writeInt(((Integer) data.get(794))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(795))); + (encoder).writeInt(((Integer) data.get(796))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(797))); + (encoder).writeInt(((Integer) data.get(798))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(799))); + (encoder).writeInt(((Integer) data.get(800))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(801))); + (encoder).writeInt(((Integer) data.get(802))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(803))); + (encoder).writeInt(((Integer) data.get(804))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(805))); + (encoder).writeInt(((Integer) data.get(806))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(807))); + (encoder).writeInt(((Integer) data.get(808))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(809))); + (encoder).writeInt(((Integer) data.get(810))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(811))); + (encoder).writeInt(((Integer) data.get(812))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(813))); + (encoder).writeInt(((Integer) data.get(814))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(815))); + (encoder).writeInt(((Integer) data.get(816))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(817))); + (encoder).writeInt(((Integer) data.get(818))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(819))); + (encoder).writeInt(((Integer) data.get(820))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(821))); + (encoder).writeInt(((Integer) data.get(822))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(823))); + (encoder).writeInt(((Integer) data.get(824))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(825))); + (encoder).writeInt(((Integer) data.get(826))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(827))); + (encoder).writeInt(((Integer) data.get(828))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(829))); + (encoder).writeInt(((Integer) data.get(830))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(831))); + (encoder).writeInt(((Integer) data.get(832))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(833))); + (encoder).writeInt(((Integer) data.get(834))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(835))); + (encoder).writeInt(((Integer) data.get(836))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(837))); + (encoder).writeInt(((Integer) data.get(838))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(839))); + (encoder).writeInt(((Integer) data.get(840))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(841))); + (encoder).writeInt(((Integer) data.get(842))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(843))); + (encoder).writeInt(((Integer) data.get(844))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(845))); + (encoder).writeInt(((Integer) data.get(846))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(847))); + (encoder).writeInt(((Integer) data.get(848))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(849))); + (encoder).writeInt(((Integer) data.get(850))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(851))); + (encoder).writeInt(((Integer) data.get(852))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(853))); + (encoder).writeInt(((Integer) data.get(854))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(855))); + (encoder).writeInt(((Integer) data.get(856))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(857))); + (encoder).writeInt(((Integer) data.get(858))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(859))); + (encoder).writeInt(((Integer) data.get(860))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(861))); + (encoder).writeInt(((Integer) data.get(862))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(863))); + (encoder).writeInt(((Integer) data.get(864))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(865))); + (encoder).writeInt(((Integer) data.get(866))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(867))); + (encoder).writeInt(((Integer) data.get(868))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(869))); + (encoder).writeInt(((Integer) data.get(870))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(871))); + (encoder).writeInt(((Integer) data.get(872))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(873))); + (encoder).writeInt(((Integer) data.get(874))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(875))); + (encoder).writeInt(((Integer) data.get(876))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(877))); + (encoder).writeInt(((Integer) data.get(878))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(879))); + (encoder).writeInt(((Integer) data.get(880))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(881))); + (encoder).writeInt(((Integer) data.get(882))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(883))); + (encoder).writeInt(((Integer) data.get(884))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(885))); + (encoder).writeInt(((Integer) data.get(886))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(887))); + (encoder).writeInt(((Integer) data.get(888))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(889))); + (encoder).writeInt(((Integer) data.get(890))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(891))); + (encoder).writeInt(((Integer) data.get(892))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(893))); + (encoder).writeInt(((Integer) data.get(894))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(895))); + (encoder).writeInt(((Integer) data.get(896))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(897))); + (encoder).writeInt(((Integer) data.get(898))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(899))); + (encoder).writeInt(((Integer) data.get(900))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(901))); + (encoder).writeInt(((Integer) data.get(902))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(903))); + (encoder).writeInt(((Integer) data.get(904))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(905))); + (encoder).writeInt(((Integer) data.get(906))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(907))); + (encoder).writeInt(((Integer) data.get(908))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(909))); + (encoder).writeInt(((Integer) data.get(910))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(911))); + (encoder).writeInt(((Integer) data.get(912))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(913))); + (encoder).writeInt(((Integer) data.get(914))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(915))); + (encoder).writeInt(((Integer) data.get(916))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(917))); + (encoder).writeInt(((Integer) data.get(918))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(919))); + (encoder).writeInt(((Integer) data.get(920))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(921))); + (encoder).writeInt(((Integer) data.get(922))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(923))); + (encoder).writeInt(((Integer) data.get(924))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(925))); + (encoder).writeInt(((Integer) data.get(926))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(927))); + (encoder).writeInt(((Integer) data.get(928))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(929))); + (encoder).writeInt(((Integer) data.get(930))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(931))); + (encoder).writeInt(((Integer) data.get(932))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(933))); + (encoder).writeInt(((Integer) data.get(934))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(935))); + (encoder).writeInt(((Integer) data.get(936))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(937))); + (encoder).writeInt(((Integer) data.get(938))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(939))); + (encoder).writeInt(((Integer) data.get(940))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(941))); + (encoder).writeInt(((Integer) data.get(942))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(943))); + (encoder).writeInt(((Integer) data.get(944))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(945))); + (encoder).writeInt(((Integer) data.get(946))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(947))); + (encoder).writeInt(((Integer) data.get(948))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(949))); + (encoder).writeInt(((Integer) data.get(950))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(951))); + (encoder).writeInt(((Integer) data.get(952))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(953))); + (encoder).writeInt(((Integer) data.get(954))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(955))); + (encoder).writeInt(((Integer) data.get(956))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(957))); + (encoder).writeInt(((Integer) data.get(958))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(959))); + (encoder).writeInt(((Integer) data.get(960))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(961))); + (encoder).writeInt(((Integer) data.get(962))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(963))); + (encoder).writeInt(((Integer) data.get(964))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(965))); + (encoder).writeInt(((Integer) data.get(966))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(967))); + (encoder).writeInt(((Integer) data.get(968))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(969))); + (encoder).writeInt(((Integer) data.get(970))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(971))); + (encoder).writeInt(((Integer) data.get(972))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(973))); + (encoder).writeInt(((Integer) data.get(974))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(975))); + (encoder).writeInt(((Integer) data.get(976))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(977))); + (encoder).writeInt(((Integer) data.get(978))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(979))); + (encoder).writeInt(((Integer) data.get(980))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(981))); + (encoder).writeInt(((Integer) data.get(982))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(983))); + (encoder).writeInt(((Integer) data.get(984))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(985))); + (encoder).writeInt(((Integer) data.get(986))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(987))); + (encoder).writeInt(((Integer) data.get(988))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(989))); + (encoder).writeInt(((Integer) data.get(990))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(991))); + (encoder).writeInt(((Integer) data.get(992))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(993))); + (encoder).writeInt(((Integer) data.get(994))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(995))); + (encoder).writeInt(((Integer) data.get(996))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(997))); + (encoder).writeInt(((Integer) data.get(998))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(999))); + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java new file mode 100644 index 000000000..ab682d45a --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java @@ -0,0 +1,114 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239 + implements FastSerializer +{ + + private final Schema testEnumEnumSchema0 = Schema.parse("{\"type\":\"enum\",\"name\":\"testEnum\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"symbols\":[\"A\",\"B\"]}"); + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + int valueToWrite0; + Object enumValue0 = data.get(0); + if (enumValue0 instanceof Enum) { + valueToWrite0 = ((Enum) enumValue0).ordinal(); + } else { + valueToWrite0 = testEnumEnumSchema0 .getEnumOrdinal(((GenericEnumSymbol) data.get(0)).toString()); + } + (encoder).writeEnum(valueToWrite0); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + GenericEnumSymbol testEnumUnion0 = ((GenericEnumSymbol) data.get(1)); + if (testEnumUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + int valueToWrite1; + Object enumValue1 = testEnumUnion0; + if (enumValue1 instanceof Enum) { + valueToWrite1 = ((Enum) enumValue1).ordinal(); + } else { + valueToWrite1 = testEnumEnumSchema0 .getEnumOrdinal(((GenericEnumSymbol) testEnumUnion0).toString()); + } + (encoder).writeEnum(valueToWrite1); + } + List testEnumArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testEnumArray0 == null)||testEnumArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testEnumArray0 .size()); + for (int counter0 = 0; (counter0 testEnumUnionArray0 = ((List ) data.get(3)); + (encoder).writeArrayStart(); + if ((testEnumUnionArray0 == null)||testEnumUnionArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testEnumUnionArray0 .size()); + for (int counter1 = 0; (counter1 ) testEnumUnionArray0).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + int valueToWrite3; + Object enumValue3 = union0; + if (enumValue3 instanceof Enum) { + valueToWrite3 = ((Enum) enumValue3).ordinal(); + } else { + valueToWrite3 = testEnumEnumSchema0 .getEnumOrdinal(((GenericEnumSymbol) union0).toString()); + } + (encoder).writeEnum(valueToWrite3); + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java new file mode 100644 index 000000000..f011d2592 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java @@ -0,0 +1,84 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + GenericFixed testFixedUnion0 = ((GenericFixed) data.get(1)); + if (testFixedUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeFixed(((GenericFixed) testFixedUnion0).bytes()); + } + List testFixedArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testFixedArray0 == null)||testFixedArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testFixedArray0 .size()); + for (int counter0 = 0; (counter0 testFixedUnionArray0 = ((List ) data.get(3)); + (encoder).writeArrayStart(); + if ((testFixedUnionArray0 == null)||testFixedUnionArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testFixedUnionArray0 .size()); + for (int counter1 = 0; (counter1 ) testFixedUnionArray0).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeFixed(((GenericFixed) union0).bytes()); + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java new file mode 100644 index 000000000..80e33e620 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java @@ -0,0 +1,70 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object union0 = ((Object) data.get(0)); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } else { + if (union0 instanceof CharSequence) { + (encoder).writeIndex(2); + if (((CharSequence) union0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) union0))); + } else { + (encoder).writeString(((CharSequence) union0).toString()); + } + } else { + if (union0 instanceof Integer) { + (encoder).writeIndex(3); + (encoder).writeInt(((Integer) union0)); + } + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java new file mode 100644 index 000000000..d9db78804 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java @@ -0,0 +1,157 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import java.nio.ByteBuffer; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Integer testIntUnion0 = ((Integer) data.get(1)); + if (testIntUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeInt(((Integer) testIntUnion0)); + } + Integer testFlippedIntUnion0 = ((Integer) data.get(2)); + if (testFlippedIntUnion0 == null) { + (encoder).writeIndex(1); + (encoder).writeNull(); + } else { + (encoder).writeIndex(0); + (encoder).writeInt(((Integer) testFlippedIntUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(3)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(3)))); + } else { + (encoder).writeString(((CharSequence) data.get(3)).toString()); + } + CharSequence testStringUnion0 = ((CharSequence) data.get(4)); + if (testStringUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testStringUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringUnion0))); + } else { + (encoder).writeString(((CharSequence) testStringUnion0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeLong(((Long) data.get(5))); + Long testLongUnion0 = ((Long) data.get(6)); + if (testLongUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeLong(((Long) testLongUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeDouble(((Double) data.get(7))); + Double testDoubleUnion0 = ((Double) data.get(8)); + if (testDoubleUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeDouble(((Double) testDoubleUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFloat(((Float) data.get(9))); + Float testFloatUnion0 = ((Float) data.get(10)); + if (testFloatUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeFloat(((Float) testFloatUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeBoolean(((Boolean) data.get(11))); + Boolean testBooleanUnion0 = ((Boolean) data.get(12)); + if (testBooleanUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeBoolean(((Boolean) testBooleanUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeBytes(((ByteBuffer) data.get(13))); + ByteBuffer testBytesUnion0 = ((ByteBuffer) data.get(14)); + if (testBytesUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeBytes(((ByteBuffer) testBytesUnion0)); + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java new file mode 100644 index 000000000..e12a1dac5 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object union_field0 = ((Object) data.get(0)); + if (union_field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record1".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord10(((IndexedRecord) union_field0), (encoder), (customization)); + } else { + if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record2".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { + (encoder).writeIndex(2); + serializeRecord20(((IndexedRecord) union_field0), (encoder), (customization)); + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + } + + @SuppressWarnings("unchecked") + public void serializeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java new file mode 100644 index 000000000..338a34abc --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java @@ -0,0 +1,158 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List recordsArray0 = ((List ) data.get(0)); + (encoder).writeArrayStart(); + if ((recordsArray0 == null)||recordsArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsArray0 .size()); + for (int counter0 = 0; (counter0 ) recordsArray0).get(counter0); + serializeSubRecord0(subRecord0, (encoder), (customization)); + } + } + (encoder).writeArrayEnd(); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map recordsMap0 = ((Map ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMap0); + } + (encoder).writeMapStart(); + if ((recordsMap0 == null)||recordsMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsMap0 .size()); + for (CharSequence key0 : ((Map ) recordsMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord subRecord1 = null; + subRecord1 = ((Map ) recordsMap0).get(key0); + serializeSubRecord0(subRecord1, (encoder), (customization)); + } + } + (encoder).writeMapEnd(); + List recordsArrayUnion0 = ((List ) data.get(2)); + if (recordsArrayUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsArrayUnion0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) recordsArrayUnion0) == null)||((List ) recordsArrayUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) recordsArrayUnion0).size()); + for (int counter1 = 0; (counter1 <((List ) recordsArrayUnion0).size()); counter1 ++) { + (encoder).startItem(); + IndexedRecord union0 = null; + union0 = ((List )((List ) recordsArrayUnion0)).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map recordsMapUnion0 = ((Map ) data.get(3)); + if (recordsMapUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsMapUnion0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map ) recordsMapUnion0)); + } + (encoder).writeMapStart(); + if ((((Map ) recordsMapUnion0) == null)||((Map ) recordsMapUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map ) recordsMapUnion0).size()); + for (CharSequence key1 : ((Map )((Map ) recordsMapUnion0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + IndexedRecord union1 = null; + union1 = ((Map )((Map ) recordsMapUnion0)).get(key1); + if (union1 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java new file mode 100644 index 000000000..1cfcf0a2f --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java @@ -0,0 +1,230 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List> recordsArrayMap0 = ((List> ) data.get(0)); + (encoder).writeArrayStart(); + if ((recordsArrayMap0 == null)||recordsArrayMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsArrayMap0 .size()); + for (int counter0 = 0; (counter0 map0 = null; + map0 = ((List> ) recordsArrayMap0).get(counter0); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map0); + } + (encoder).writeMapStart(); + if ((map0 == null)||map0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(map0 .size()); + for (CharSequence key0 : ((Map ) map0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord union0 = null; + union0 = ((Map ) map0).get(key0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + (encoder).writeArrayEnd(); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map> recordsMapArray0 = ((Map> ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMapArray0); + } + (encoder).writeMapStart(); + if ((recordsMapArray0 == null)||recordsMapArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsMapArray0 .size()); + for (CharSequence key1 : ((Map> ) recordsMapArray0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + List array0 = null; + array0 = ((Map> ) recordsMapArray0).get(key1); + (encoder).writeArrayStart(); + if ((array0 == null)||array0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array0 .size()); + for (int counter1 = 0; (counter1 ) array0).get(counter1); + if (union1 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + (encoder).writeMapEnd(); + List> recordsArrayMapUnion0 = ((List> ) data.get(2)); + if (recordsArrayMapUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsArrayMapUnion0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List> ) recordsArrayMapUnion0) == null)||((List> ) recordsArrayMapUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List> ) recordsArrayMapUnion0).size()); + for (int counter2 = 0; (counter2 <((List> ) recordsArrayMapUnion0).size()); counter2 ++) { + (encoder).startItem(); + Map map1 = null; + map1 = ((List> )((List> ) recordsArrayMapUnion0)).get(counter2); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map1); + } + (encoder).writeMapStart(); + if ((map1 == null)||map1 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(map1 .size()); + for (CharSequence key2 : ((Map ) map1).keySet()) { + (encoder).startItem(); + (encoder).writeString(key2); + IndexedRecord union2 = null; + union2 = ((Map ) map1).get(key2); + if (union2 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union2 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union2).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union2), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + (encoder).writeArrayEnd(); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map> recordsMapArrayUnion0 = ((Map> ) data.get(3)); + if (recordsMapArrayUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsMapArrayUnion0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map> ) recordsMapArrayUnion0)); + } + (encoder).writeMapStart(); + if ((((Map> ) recordsMapArrayUnion0) == null)||((Map> ) recordsMapArrayUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map> ) recordsMapArrayUnion0).size()); + for (CharSequence key3 : ((Map> )((Map> ) recordsMapArrayUnion0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key3); + List array1 = null; + array1 = ((Map> )((Map> ) recordsMapArrayUnion0)).get(key3); + (encoder).writeArrayStart(); + if ((array1 == null)||array1 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array1 .size()); + for (int counter3 = 0; (counter3 ) array1).get(counter3); + if (union3 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union3 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union3).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union3), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + (encoder).writeMapEnd(); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java new file mode 100644 index 000000000..b397ad2c2 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + IndexedRecord record0 = ((IndexedRecord) data.get(0)); + if (record0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((record0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) record0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) record0), (encoder), (customization)); + } + } + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + IndexedRecord record10 = ((IndexedRecord) data.get(1)); + serializeSubRecord0(record10, (encoder), (customization)); + CharSequence field0 = ((CharSequence) data.get(2)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastSerdeEnums_GenericSerializer_808559686.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastSerdeEnums_GenericSerializer_808559686.java new file mode 100644 index 000000000..11c38e78b --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastSerdeEnums_GenericSerializer_808559686.java @@ -0,0 +1,97 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeEnums_GenericSerializer_808559686 + implements FastSerializer +{ + + private final Schema justSimpleEnumEnumSchema0 = Schema.parse("{\"type\":\"enum\",\"name\":\"JustSimpleEnum\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"symbols\":[\"E1\",\"E2\",\"E3\",\"E4\",\"E5\"]}"); + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + int valueToWrite0; + Object enumValue0 = data.get(0); + if (enumValue0 instanceof Enum) { + valueToWrite0 = ((Enum) enumValue0).ordinal(); + } else { + valueToWrite0 = justSimpleEnumEnumSchema0 .getEnumOrdinal(((GenericEnumSymbol) data.get(0)).toString()); + } + (encoder).writeEnum(valueToWrite0); + serialize_FastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List arrayOfEnums0 = ((List ) data.get(1)); + if (arrayOfEnums0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (arrayOfEnums0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) arrayOfEnums0) == null)||((List ) arrayOfEnums0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) arrayOfEnums0).size()); + for (int counter0 = 0; (counter0 <((List ) arrayOfEnums0).size()); counter0 ++) { + (encoder).startItem(); + int valueToWrite1; + Object enumValue1 = ((List ) arrayOfEnums0).get(counter0); + if (enumValue1 instanceof Enum) { + valueToWrite1 = ((Enum) enumValue1).ordinal(); + } else { + valueToWrite1 = justSimpleEnumEnumSchema0 .getEnumOrdinal(((GenericEnumSymbol)((List ) arrayOfEnums0).get(counter0)).toString()); + } + (encoder).writeEnum(valueToWrite1); + } + } + (encoder).writeArrayEnd(); + } + } + Map mapOfEnums0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfEnums0); + } + (encoder).writeMapStart(); + if ((mapOfEnums0 == null)||mapOfEnums0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfEnums0 .size()); + for (CharSequence key0 : ((Map ) mapOfEnums0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + int valueToWrite2; + Object enumValue2 = mapOfEnums0 .get(key0); + if (enumValue2 instanceof Enum) { + valueToWrite2 = ((Enum) enumValue2).ordinal(); + } else { + valueToWrite2 = justSimpleEnumEnumSchema0 .getEnumOrdinal(((GenericEnumSymbol) mapOfEnums0 .get(key0)).toString()); + } + (encoder).writeEnum(valueToWrite2); + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastSerdeFixed_GenericSerializer_2095283755.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastSerdeFixed_GenericSerializer_2095283755.java new file mode 100644 index 000000000..70165e18d --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastSerdeFixed_GenericSerializer_2095283755.java @@ -0,0 +1,74 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeFixed_GenericSerializer_2095283755 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List arrayOfFixed0 = ((List ) data.get(1)); + if (arrayOfFixed0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (arrayOfFixed0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) arrayOfFixed0) == null)||((List ) arrayOfFixed0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) arrayOfFixed0).size()); + for (int counter0 = 0; (counter0 <((List ) arrayOfFixed0).size()); counter0 ++) { + (encoder).startItem(); + (encoder).writeFixed(((GenericFixed)((List ) arrayOfFixed0).get(counter0)).bytes()); + } + } + (encoder).writeArrayEnd(); + } + } + Map mapOfFixed0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfFixed0); + } + (encoder).writeMapStart(); + if ((mapOfFixed0 == null)||mapOfFixed0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfFixed0 .size()); + for (CharSequence key0 : ((Map ) mapOfFixed0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + (encoder).writeFixed(((GenericFixed) mapOfFixed0 .get(key0)).bytes()); + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java new file mode 100644 index 000000000..e819ac442 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java @@ -0,0 +1,97 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence testUnionString0 = ((CharSequence) data.get(1)); + if (testUnionString0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testUnionString0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testUnionString0))); + } else { + (encoder).writeString(((CharSequence) testUnionString0).toString()); + } + } + List testStringArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testStringArray0 == null)||testStringArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringArray0 .size()); + for (int counter0 = 0; (counter0 testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } + (encoder).writeMapStart(); + if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringMap0 .size()); + for (CharSequence key0 : ((Map ) testStringMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) testStringMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) testStringMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java new file mode 100644 index 000000000..0bf8a2132 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java @@ -0,0 +1,97 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_FastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence testUnionString0 = ((CharSequence) data.get(1)); + if (testUnionString0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testUnionString0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testUnionString0))); + } else { + (encoder).writeString(((CharSequence) testUnionString0).toString()); + } + } + List testStringArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testStringArray0 == null)||testStringArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringArray0 .size()); + for (int counter0 = 0; (counter0 testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } + (encoder).writeMapStart(); + if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringMap0 .size()); + for (CharSequence key0 : ((Map ) testStringMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) testStringMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) testStringMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/Map_of_UNION_GenericSerializer_2140000109.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/Map_of_UNION_GenericSerializer_2140000109.java new file mode 100644 index 000000000..5ec091b84 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/Map_of_UNION_GenericSerializer_2140000109.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Map_of_UNION_GenericSerializer_2140000109 + implements FastSerializer> +{ + + + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } + (encoder).writeMapStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (CharSequence key0 : ((Map ) data).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord union0 = null; + union0 = ((Map ) data).get(key0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/Map_of_record_GenericSerializer_1677529043.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/Map_of_record_GenericSerializer_1677529043.java new file mode 100644 index 000000000..7487d7de9 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/Map_of_record_GenericSerializer_1677529043.java @@ -0,0 +1,57 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Map_of_record_GenericSerializer_1677529043 + implements FastSerializer> +{ + + + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } + (encoder).writeMapStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (CharSequence key0 : ((Map ) data).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord record0 = null; + record0 = ((Map ) data).get(key0); + serializeRecord0(record0, (encoder), (customization)); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/StringableRecord_SpecificSerializer_842267318.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/StringableRecord_SpecificSerializer_842267318.java new file mode 100644 index 000000000..0af8bddb2 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/StringableRecord_SpecificSerializer_842267318.java @@ -0,0 +1,189 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord; +import com.linkedin.avro.fastserde.generated.avro.StringableRecord; +import com.linkedin.avro.fastserde.generated.avro.StringableSubRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class StringableRecord_SpecificSerializer_842267318 + implements FastSerializer +{ + + + public void serialize(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeStringableRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_StringableRecord0(data, (encoder), (customization)); + serialize_StringableRecord1(data, (encoder), (customization)); + serialize_StringableRecord2(data, (encoder), (customization)); + serialize_StringableRecord3(data, (encoder), (customization)); + serialize_StringableRecord4(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(1)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(1)))); + } else { + (encoder).writeString(((CharSequence) data.get(1)).toString()); + } + if (((CharSequence) data.get(2)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(2)))); + } else { + (encoder).writeString(((CharSequence) data.get(2)).toString()); + } + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord1(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(3)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(3)))); + } else { + (encoder).writeString(((CharSequence) data.get(3)).toString()); + } + if (((CharSequence) data.get(4)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(4)))); + } else { + (encoder).writeString(((CharSequence) data.get(4)).toString()); + } + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord2(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List urlArray0 = ((List ) data.get(5)); + (encoder).writeArrayStart(); + if ((urlArray0 == null)||urlArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(urlArray0 .size()); + for (int counter0 = 0; (counter0 urlMap0 = ((Map ) data.get(6)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(urlMap0); + } + (encoder).writeMapStart(); + if ((urlMap0 == null)||urlMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(urlMap0 .size()); + for (CharSequence key0 : ((Map ) urlMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) urlMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) urlMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) urlMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord3(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord0 = ((StringableSubRecord) data.get(7)); + serializeStringableSubRecord0(subRecord0, (encoder), (customization)); + AnotherSubRecord subRecordWithSubRecord0 = ((AnotherSubRecord) data.get(8)); + serializeAnotherSubRecord0(subRecordWithSubRecord0, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_StringableSubRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object nullStringIntUnion0 = ((Object) data.get(1)); + if (nullStringIntUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (nullStringIntUnion0 instanceof CharSequence) { + (encoder).writeIndex(1); + if (((CharSequence) nullStringIntUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) nullStringIntUnion0))); + } else { + (encoder).writeString(((CharSequence) nullStringIntUnion0).toString()); + } + } else { + if (nullStringIntUnion0 instanceof Integer) { + (encoder).writeIndex(2); + (encoder).writeInt(((Integer) nullStringIntUnion0)); + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeAnotherSubRecord0(AnotherSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord1 = ((StringableSubRecord) data.get(0)); + serializeStringableSubRecord0(subRecord1, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord4(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence stringUnion0 = ((CharSequence) data.get(9)); + if (stringUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) stringUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) stringUnion0))); + } else { + (encoder).writeString(((CharSequence) stringUnion0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/TestArrayOfFloats_GenericSerializer_1408566797.java b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/TestArrayOfFloats_GenericSerializer_1408566797.java new file mode 100644 index 000000000..af4f0ee77 --- /dev/null +++ b/fastserde/avro-fastserde-tests14/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_4/TestArrayOfFloats_GenericSerializer_1408566797.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_4; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class TestArrayOfFloats_GenericSerializer_1408566797 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeTestArrayOfFloats0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeTestArrayOfFloats0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List array_of_float0 = ((List ) data.get(0)); + (encoder).writeArrayStart(); + if ((array_of_float0 == null)||array_of_float0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array_of_float0 .size()); + Object array0 = array_of_float0; + if (array0 instanceof PrimitiveFloatList) { + PrimitiveFloatList primitiveList0 = ((PrimitiveFloatList) array0); + if (primitiveList0 instanceof BufferBackedPrimitiveFloatList) { + BufferBackedPrimitiveFloatList bufferBackedPrimitiveFloatList = ((BufferBackedPrimitiveFloatList) primitiveList0); + bufferBackedPrimitiveFloatList.writeFloats((encoder)); + } else { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_BOOLEAN_GenericDeserializer_869749973_869749973(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveBooleanList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveBooleanList) { + array0 = ((PrimitiveBooleanList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveBooleanArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_DOUBLE_GenericDeserializer_18760307_18760307(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveDoubleList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveDoubleList) { + array0 = ((PrimitiveDoubleList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveDoubleArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_FLOAT_GenericDeserializer_1012670397_1012670397(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveFloatList array0 = null; + array0 = ((PrimitiveFloatList) BufferBackedPrimitiveFloatList.readPrimitiveFloatArray((reuse), (decoder))); + return array0; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/Array_of_INT_GenericDeserializer_1012089072_1012089072.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/Array_of_INT_GenericDeserializer_1012089072_1012089072.java new file mode 100644 index 000000000..2051604a4 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/Array_of_INT_GenericDeserializer_1012089072_1012089072.java @@ -0,0 +1,43 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class Array_of_INT_GenericDeserializer_1012089072_1012089072 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Array_of_INT_GenericDeserializer_1012089072_1012089072(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveIntList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveIntList) { + array0 = ((PrimitiveIntList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_LONG_GenericDeserializer_325099267_325099267(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveLongList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveLongList) { + array0 = ((PrimitiveLongList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveLongArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_TestRecord_SpecificDeserializer_1088113243_1088113243(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema arrayArrayElemSchema0; + private final Schema arrayElemOptionSchema0; + private final Schema field0; + + public Array_of_UNION_GenericDeserializer_777827233_777827233(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArrayElemSchema0 = readerSchema.getElementType(); + this.arrayElemOptionSchema0 = arrayArrayElemSchema0 .getTypes().get(1); + this.field0 = arrayElemOptionSchema0 .getField("field").schema(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_UNION_SpecificDeserializer_1277939469_1277939469(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex15 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex17)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex21 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex21)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex23 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex23)); + } + } + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex25 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex25 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex25 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex25)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema unionOptionArrayElemSchema0; + + public Array_of_record_GenericDeserializer_1606337179_2018567528(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOptionArrayElemSchema0 = readerSchema.getElementType(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":{\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}}"); + } else { + if (unionIndex0 == 1) { + List unionOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + unionOption0 = ((List)(reuse)); + unionOption0 .clear(); + } else { + unionOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + private final Schema arrayArrayElemSchema0; + private final Schema field0; + + public Array_of_record_GenericDeserializer_477614132_477614132(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArrayElemSchema0 = readerSchema.getElementType(); + this.field0 = arrayArrayElemSchema0 .getField("field").schema(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema f00; + private final Schema f10; + private final Schema f20; + private final Schema f30; + private final Schema f40; + private final Schema f50; + private final Schema f60; + private final Schema f70; + private final Schema f80; + private final Schema f90; + private final Schema f100; + private final Schema f110; + private final Schema f120; + private final Schema f130; + private final Schema f140; + private final Schema f150; + private final Schema f160; + private final Schema f170; + private final Schema f180; + private final Schema f190; + private final Schema f200; + private final Schema f210; + private final Schema f220; + private final Schema f230; + private final Schema f240; + private final Schema f250; + private final Schema f260; + private final Schema f270; + private final Schema f280; + private final Schema f290; + private final Schema f300; + private final Schema f310; + private final Schema f320; + private final Schema f330; + private final Schema f340; + private final Schema f350; + private final Schema f360; + private final Schema f370; + private final Schema f380; + private final Schema f390; + private final Schema f400; + private final Schema f410; + private final Schema f420; + private final Schema f430; + private final Schema f440; + private final Schema f450; + private final Schema f460; + private final Schema f470; + private final Schema f480; + private final Schema f490; + private final Schema f500; + private final Schema f510; + private final Schema f520; + private final Schema f530; + private final Schema f540; + private final Schema f550; + private final Schema f560; + private final Schema f570; + private final Schema f580; + private final Schema f590; + private final Schema f600; + private final Schema f610; + private final Schema f620; + private final Schema f630; + private final Schema f640; + private final Schema f650; + private final Schema f660; + private final Schema f670; + private final Schema f680; + private final Schema f690; + private final Schema f700; + private final Schema f710; + private final Schema f720; + private final Schema f730; + private final Schema f740; + private final Schema f750; + private final Schema f760; + private final Schema f770; + private final Schema f780; + private final Schema f790; + private final Schema f800; + private final Schema f810; + private final Schema f820; + private final Schema f830; + private final Schema f840; + private final Schema f850; + private final Schema f860; + private final Schema f870; + private final Schema f880; + private final Schema f890; + private final Schema f900; + private final Schema f910; + private final Schema f920; + private final Schema f930; + private final Schema f940; + private final Schema f950; + private final Schema f960; + private final Schema f970; + private final Schema f980; + private final Schema f990; + private final Schema f1000; + private final Schema f1010; + private final Schema f1020; + private final Schema f1030; + private final Schema f1040; + private final Schema f1050; + private final Schema f1060; + private final Schema f1070; + private final Schema f1080; + private final Schema f1090; + private final Schema f1100; + private final Schema f1110; + private final Schema f1120; + private final Schema f1130; + private final Schema f1140; + private final Schema f1150; + private final Schema f1160; + private final Schema f1170; + private final Schema f1180; + private final Schema f1190; + private final Schema f1200; + private final Schema f1210; + private final Schema f1220; + private final Schema f1230; + private final Schema f1240; + private final Schema f1250; + private final Schema f1260; + private final Schema f1270; + private final Schema f1280; + private final Schema f1290; + private final Schema f1300; + private final Schema f1310; + private final Schema f1320; + private final Schema f1330; + private final Schema f1340; + private final Schema f1350; + private final Schema f1360; + private final Schema f1370; + private final Schema f1380; + private final Schema f1390; + private final Schema f1400; + private final Schema f1410; + private final Schema f1420; + private final Schema f1430; + private final Schema f1440; + private final Schema f1450; + private final Schema f1460; + private final Schema f1470; + private final Schema f1480; + private final Schema f1490; + private final Schema f1500; + private final Schema f1510; + private final Schema f1520; + private final Schema f1530; + private final Schema f1540; + private final Schema f1550; + private final Schema f1560; + private final Schema f1570; + private final Schema f1580; + private final Schema f1590; + private final Schema f1600; + private final Schema f1610; + private final Schema f1620; + private final Schema f1630; + private final Schema f1640; + private final Schema f1650; + private final Schema f1660; + private final Schema f1670; + private final Schema f1680; + private final Schema f1690; + private final Schema f1700; + private final Schema f1710; + private final Schema f1720; + private final Schema f1730; + private final Schema f1740; + private final Schema f1750; + private final Schema f1760; + private final Schema f1770; + private final Schema f1780; + private final Schema f1790; + private final Schema f1800; + private final Schema f1810; + private final Schema f1820; + private final Schema f1830; + private final Schema f1840; + private final Schema f1850; + private final Schema f1860; + private final Schema f1870; + private final Schema f1880; + private final Schema f1890; + private final Schema f1900; + private final Schema f1910; + private final Schema f1920; + private final Schema f1930; + private final Schema f1940; + private final Schema f1950; + private final Schema f1960; + private final Schema f1970; + private final Schema f1980; + private final Schema f1990; + private final Schema f2000; + private final Schema f2010; + private final Schema f2020; + private final Schema f2030; + private final Schema f2040; + private final Schema f2050; + private final Schema f2060; + private final Schema f2070; + private final Schema f2080; + private final Schema f2090; + private final Schema f2100; + private final Schema f2110; + private final Schema f2120; + private final Schema f2130; + private final Schema f2140; + private final Schema f2150; + private final Schema f2160; + private final Schema f2170; + private final Schema f2180; + private final Schema f2190; + private final Schema f2200; + private final Schema f2210; + private final Schema f2220; + private final Schema f2230; + private final Schema f2240; + private final Schema f2250; + private final Schema f2260; + private final Schema f2270; + private final Schema f2280; + private final Schema f2290; + private final Schema f2300; + private final Schema f2310; + private final Schema f2320; + private final Schema f2330; + private final Schema f2340; + private final Schema f2350; + private final Schema f2360; + private final Schema f2370; + private final Schema f2380; + private final Schema f2390; + private final Schema f2400; + private final Schema f2410; + private final Schema f2420; + private final Schema f2430; + private final Schema f2440; + private final Schema f2450; + private final Schema f2460; + private final Schema f2470; + private final Schema f2480; + private final Schema f2490; + private final Schema f2500; + private final Schema f2510; + private final Schema f2520; + private final Schema f2530; + private final Schema f2540; + private final Schema f2550; + private final Schema f2560; + private final Schema f2570; + private final Schema f2580; + private final Schema f2590; + private final Schema f2600; + private final Schema f2610; + private final Schema f2620; + private final Schema f2630; + private final Schema f2640; + private final Schema f2650; + private final Schema f2660; + private final Schema f2670; + private final Schema f2680; + private final Schema f2690; + private final Schema f2700; + private final Schema f2710; + private final Schema f2720; + private final Schema f2730; + private final Schema f2740; + private final Schema f2750; + private final Schema f2760; + private final Schema f2770; + private final Schema f2780; + private final Schema f2790; + private final Schema f2800; + private final Schema f2810; + private final Schema f2820; + private final Schema f2830; + private final Schema f2840; + private final Schema f2850; + private final Schema f2860; + private final Schema f2870; + private final Schema f2880; + private final Schema f2890; + private final Schema f2900; + private final Schema f2910; + private final Schema f2920; + private final Schema f2930; + private final Schema f2940; + private final Schema f2950; + private final Schema f2960; + private final Schema f2970; + private final Schema f2980; + private final Schema f2990; + private final Schema f3000; + private final Schema f3010; + private final Schema f3020; + private final Schema f3030; + private final Schema f3040; + private final Schema f3050; + private final Schema f3060; + private final Schema f3070; + private final Schema f3080; + private final Schema f3090; + private final Schema f3100; + private final Schema f3110; + private final Schema f3120; + private final Schema f3130; + private final Schema f3140; + private final Schema f3150; + private final Schema f3160; + private final Schema f3170; + private final Schema f3180; + private final Schema f3190; + private final Schema f3200; + private final Schema f3210; + private final Schema f3220; + private final Schema f3230; + private final Schema f3240; + private final Schema f3250; + private final Schema f3260; + private final Schema f3270; + private final Schema f3280; + private final Schema f3290; + private final Schema f3300; + private final Schema f3310; + private final Schema f3320; + private final Schema f3330; + private final Schema f3340; + private final Schema f3350; + private final Schema f3360; + private final Schema f3370; + private final Schema f3380; + private final Schema f3390; + private final Schema f3400; + private final Schema f3410; + private final Schema f3420; + private final Schema f3430; + private final Schema f3440; + private final Schema f3450; + private final Schema f3460; + private final Schema f3470; + private final Schema f3480; + private final Schema f3490; + private final Schema f3500; + private final Schema f3510; + private final Schema f3520; + private final Schema f3530; + private final Schema f3540; + private final Schema f3550; + private final Schema f3560; + private final Schema f3570; + private final Schema f3580; + private final Schema f3590; + private final Schema f3600; + private final Schema f3610; + private final Schema f3620; + private final Schema f3630; + private final Schema f3640; + private final Schema f3650; + private final Schema f3660; + private final Schema f3670; + private final Schema f3680; + private final Schema f3690; + private final Schema f3700; + private final Schema f3710; + private final Schema f3720; + private final Schema f3730; + private final Schema f3740; + private final Schema f3750; + private final Schema f3760; + private final Schema f3770; + private final Schema f3780; + private final Schema f3790; + private final Schema f3800; + private final Schema f3810; + private final Schema f3820; + private final Schema f3830; + private final Schema f3840; + private final Schema f3850; + private final Schema f3860; + private final Schema f3870; + private final Schema f3880; + private final Schema f3890; + private final Schema f3900; + private final Schema f3910; + private final Schema f3920; + private final Schema f3930; + private final Schema f3940; + private final Schema f3950; + private final Schema f3960; + private final Schema f3970; + private final Schema f3980; + private final Schema f3990; + private final Schema f4000; + private final Schema f4010; + private final Schema f4020; + private final Schema f4030; + private final Schema f4040; + private final Schema f4050; + private final Schema f4060; + private final Schema f4070; + private final Schema f4080; + private final Schema f4090; + private final Schema f4100; + private final Schema f4110; + private final Schema f4120; + private final Schema f4130; + private final Schema f4140; + private final Schema f4150; + private final Schema f4160; + private final Schema f4170; + private final Schema f4180; + private final Schema f4190; + private final Schema f4200; + private final Schema f4210; + private final Schema f4220; + private final Schema f4230; + private final Schema f4240; + private final Schema f4250; + private final Schema f4260; + private final Schema f4270; + private final Schema f4280; + private final Schema f4290; + private final Schema f4300; + private final Schema f4310; + private final Schema f4320; + private final Schema f4330; + private final Schema f4340; + private final Schema f4350; + private final Schema f4360; + private final Schema f4370; + private final Schema f4380; + private final Schema f4390; + private final Schema f4400; + private final Schema f4410; + private final Schema f4420; + private final Schema f4430; + private final Schema f4440; + private final Schema f4450; + private final Schema f4460; + private final Schema f4470; + private final Schema f4480; + private final Schema f4490; + private final Schema f4500; + private final Schema f4510; + private final Schema f4520; + private final Schema f4530; + private final Schema f4540; + private final Schema f4550; + private final Schema f4560; + private final Schema f4570; + private final Schema f4580; + private final Schema f4590; + private final Schema f4600; + private final Schema f4610; + private final Schema f4620; + private final Schema f4630; + private final Schema f4640; + private final Schema f4650; + private final Schema f4660; + private final Schema f4670; + private final Schema f4680; + private final Schema f4690; + private final Schema f4700; + private final Schema f4710; + private final Schema f4720; + private final Schema f4730; + private final Schema f4740; + private final Schema f4750; + private final Schema f4760; + private final Schema f4770; + private final Schema f4780; + private final Schema f4790; + private final Schema f4800; + private final Schema f4810; + private final Schema f4820; + private final Schema f4830; + private final Schema f4840; + private final Schema f4850; + private final Schema f4860; + private final Schema f4870; + private final Schema f4880; + private final Schema f4890; + private final Schema f4900; + private final Schema f4910; + private final Schema f4920; + private final Schema f4930; + private final Schema f4940; + private final Schema f4950; + private final Schema f4960; + private final Schema f4970; + private final Schema f4980; + private final Schema f4990; + private final Schema f5000; + private final Schema f5010; + private final Schema f5020; + private final Schema f5030; + private final Schema f5040; + private final Schema f5050; + private final Schema f5060; + private final Schema f5070; + private final Schema f5080; + private final Schema f5090; + private final Schema f5100; + private final Schema f5110; + private final Schema f5120; + private final Schema f5130; + private final Schema f5140; + private final Schema f5150; + private final Schema f5160; + private final Schema f5170; + private final Schema f5180; + private final Schema f5190; + private final Schema f5200; + private final Schema f5210; + private final Schema f5220; + private final Schema f5230; + private final Schema f5240; + private final Schema f5250; + private final Schema f5260; + private final Schema f5270; + private final Schema f5280; + private final Schema f5290; + private final Schema f5300; + private final Schema f5310; + private final Schema f5320; + private final Schema f5330; + private final Schema f5340; + private final Schema f5350; + private final Schema f5360; + private final Schema f5370; + private final Schema f5380; + private final Schema f5390; + private final Schema f5400; + private final Schema f5410; + private final Schema f5420; + private final Schema f5430; + private final Schema f5440; + private final Schema f5450; + private final Schema f5460; + private final Schema f5470; + private final Schema f5480; + private final Schema f5490; + private final Schema f5500; + private final Schema f5510; + private final Schema f5520; + private final Schema f5530; + private final Schema f5540; + private final Schema f5550; + private final Schema f5560; + private final Schema f5570; + private final Schema f5580; + private final Schema f5590; + private final Schema f5600; + private final Schema f5610; + private final Schema f5620; + private final Schema f5630; + private final Schema f5640; + private final Schema f5650; + private final Schema f5660; + private final Schema f5670; + private final Schema f5680; + private final Schema f5690; + private final Schema f5700; + private final Schema f5710; + private final Schema f5720; + private final Schema f5730; + private final Schema f5740; + private final Schema f5750; + private final Schema f5760; + private final Schema f5770; + private final Schema f5780; + private final Schema f5790; + private final Schema f5800; + private final Schema f5810; + private final Schema f5820; + private final Schema f5830; + private final Schema f5840; + private final Schema f5850; + private final Schema f5860; + private final Schema f5870; + private final Schema f5880; + private final Schema f5890; + private final Schema f5900; + private final Schema f5910; + private final Schema f5920; + private final Schema f5930; + private final Schema f5940; + private final Schema f5950; + private final Schema f5960; + private final Schema f5970; + private final Schema f5980; + private final Schema f5990; + private final Schema f6000; + private final Schema f6010; + private final Schema f6020; + private final Schema f6030; + private final Schema f6040; + private final Schema f6050; + private final Schema f6060; + private final Schema f6070; + private final Schema f6080; + private final Schema f6090; + private final Schema f6100; + private final Schema f6110; + private final Schema f6120; + private final Schema f6130; + private final Schema f6140; + private final Schema f6150; + private final Schema f6160; + private final Schema f6170; + private final Schema f6180; + private final Schema f6190; + private final Schema f6200; + private final Schema f6210; + private final Schema f6220; + private final Schema f6230; + private final Schema f6240; + private final Schema f6250; + private final Schema f6260; + private final Schema f6270; + private final Schema f6280; + private final Schema f6290; + private final Schema f6300; + private final Schema f6310; + private final Schema f6320; + private final Schema f6330; + private final Schema f6340; + private final Schema f6350; + private final Schema f6360; + private final Schema f6370; + private final Schema f6380; + private final Schema f6390; + private final Schema f6400; + private final Schema f6410; + private final Schema f6420; + private final Schema f6430; + private final Schema f6440; + private final Schema f6450; + private final Schema f6460; + private final Schema f6470; + private final Schema f6480; + private final Schema f6490; + private final Schema f6500; + private final Schema f6510; + private final Schema f6520; + private final Schema f6530; + private final Schema f6540; + private final Schema f6550; + private final Schema f6560; + private final Schema f6570; + private final Schema f6580; + private final Schema f6590; + private final Schema f6600; + private final Schema f6610; + private final Schema f6620; + private final Schema f6630; + private final Schema f6640; + private final Schema f6650; + private final Schema f6660; + private final Schema f6670; + private final Schema f6680; + private final Schema f6690; + private final Schema f6700; + private final Schema f6710; + private final Schema f6720; + private final Schema f6730; + private final Schema f6740; + private final Schema f6750; + private final Schema f6760; + private final Schema f6770; + private final Schema f6780; + private final Schema f6790; + private final Schema f6800; + private final Schema f6810; + private final Schema f6820; + private final Schema f6830; + private final Schema f6840; + private final Schema f6850; + private final Schema f6860; + private final Schema f6870; + private final Schema f6880; + private final Schema f6890; + private final Schema f6900; + private final Schema f6910; + private final Schema f6920; + private final Schema f6930; + private final Schema f6940; + private final Schema f6950; + private final Schema f6960; + private final Schema f6970; + private final Schema f6980; + private final Schema f6990; + private final Schema f7000; + private final Schema f7010; + private final Schema f7020; + private final Schema f7030; + private final Schema f7040; + private final Schema f7050; + private final Schema f7060; + private final Schema f7070; + private final Schema f7080; + private final Schema f7090; + private final Schema f7100; + private final Schema f7110; + private final Schema f7120; + private final Schema f7130; + private final Schema f7140; + private final Schema f7150; + private final Schema f7160; + private final Schema f7170; + private final Schema f7180; + private final Schema f7190; + private final Schema f7200; + private final Schema f7210; + private final Schema f7220; + private final Schema f7230; + private final Schema f7240; + private final Schema f7250; + private final Schema f7260; + private final Schema f7270; + private final Schema f7280; + private final Schema f7290; + private final Schema f7300; + private final Schema f7310; + private final Schema f7320; + private final Schema f7330; + private final Schema f7340; + private final Schema f7350; + private final Schema f7360; + private final Schema f7370; + private final Schema f7380; + private final Schema f7390; + private final Schema f7400; + private final Schema f7410; + private final Schema f7420; + private final Schema f7430; + private final Schema f7440; + private final Schema f7450; + private final Schema f7460; + private final Schema f7470; + private final Schema f7480; + private final Schema f7490; + private final Schema f7500; + private final Schema f7510; + private final Schema f7520; + private final Schema f7530; + private final Schema f7540; + private final Schema f7550; + private final Schema f7560; + private final Schema f7570; + private final Schema f7580; + private final Schema f7590; + private final Schema f7600; + private final Schema f7610; + private final Schema f7620; + private final Schema f7630; + private final Schema f7640; + private final Schema f7650; + private final Schema f7660; + private final Schema f7670; + private final Schema f7680; + private final Schema f7690; + private final Schema f7700; + private final Schema f7710; + private final Schema f7720; + private final Schema f7730; + private final Schema f7740; + private final Schema f7750; + private final Schema f7760; + private final Schema f7770; + private final Schema f7780; + private final Schema f7790; + private final Schema f7800; + private final Schema f7810; + private final Schema f7820; + private final Schema f7830; + private final Schema f7840; + private final Schema f7850; + private final Schema f7860; + private final Schema f7870; + private final Schema f7880; + private final Schema f7890; + private final Schema f7900; + private final Schema f7910; + private final Schema f7920; + private final Schema f7930; + private final Schema f7940; + private final Schema f7950; + private final Schema f7960; + private final Schema f7970; + private final Schema f7980; + private final Schema f7990; + private final Schema f8000; + private final Schema f8010; + private final Schema f8020; + private final Schema f8030; + private final Schema f8040; + private final Schema f8050; + private final Schema f8060; + private final Schema f8070; + private final Schema f8080; + private final Schema f8090; + private final Schema f8100; + private final Schema f8110; + private final Schema f8120; + private final Schema f8130; + private final Schema f8140; + private final Schema f8150; + private final Schema f8160; + private final Schema f8170; + private final Schema f8180; + private final Schema f8190; + private final Schema f8200; + private final Schema f8210; + private final Schema f8220; + private final Schema f8230; + private final Schema f8240; + private final Schema f8250; + private final Schema f8260; + private final Schema f8270; + private final Schema f8280; + private final Schema f8290; + private final Schema f8300; + private final Schema f8310; + private final Schema f8320; + private final Schema f8330; + private final Schema f8340; + private final Schema f8350; + private final Schema f8360; + private final Schema f8370; + private final Schema f8380; + private final Schema f8390; + private final Schema f8400; + private final Schema f8410; + private final Schema f8420; + private final Schema f8430; + private final Schema f8440; + private final Schema f8450; + private final Schema f8460; + private final Schema f8470; + private final Schema f8480; + private final Schema f8490; + private final Schema f8500; + private final Schema f8510; + private final Schema f8520; + private final Schema f8530; + private final Schema f8540; + private final Schema f8550; + private final Schema f8560; + private final Schema f8570; + private final Schema f8580; + private final Schema f8590; + private final Schema f8600; + private final Schema f8610; + private final Schema f8620; + private final Schema f8630; + private final Schema f8640; + private final Schema f8650; + private final Schema f8660; + private final Schema f8670; + private final Schema f8680; + private final Schema f8690; + private final Schema f8700; + private final Schema f8710; + private final Schema f8720; + private final Schema f8730; + private final Schema f8740; + private final Schema f8750; + private final Schema f8760; + private final Schema f8770; + private final Schema f8780; + private final Schema f8790; + private final Schema f8800; + private final Schema f8810; + private final Schema f8820; + private final Schema f8830; + private final Schema f8840; + private final Schema f8850; + private final Schema f8860; + private final Schema f8870; + private final Schema f8880; + private final Schema f8890; + private final Schema f8900; + private final Schema f8910; + private final Schema f8920; + private final Schema f8930; + private final Schema f8940; + private final Schema f8950; + private final Schema f8960; + private final Schema f8970; + private final Schema f8980; + private final Schema f8990; + private final Schema f9000; + private final Schema f9010; + private final Schema f9020; + private final Schema f9030; + private final Schema f9040; + private final Schema f9050; + private final Schema f9060; + private final Schema f9070; + private final Schema f9080; + private final Schema f9090; + private final Schema f9100; + private final Schema f9110; + private final Schema f9120; + private final Schema f9130; + private final Schema f9140; + private final Schema f9150; + private final Schema f9160; + private final Schema f9170; + private final Schema f9180; + private final Schema f9190; + private final Schema f9200; + private final Schema f9210; + private final Schema f9220; + private final Schema f9230; + private final Schema f9240; + private final Schema f9250; + private final Schema f9260; + private final Schema f9270; + private final Schema f9280; + private final Schema f9290; + private final Schema f9300; + private final Schema f9310; + private final Schema f9320; + private final Schema f9330; + private final Schema f9340; + private final Schema f9350; + private final Schema f9360; + private final Schema f9370; + private final Schema f9380; + private final Schema f9390; + private final Schema f9400; + private final Schema f9410; + private final Schema f9420; + private final Schema f9430; + private final Schema f9440; + private final Schema f9450; + private final Schema f9460; + private final Schema f9470; + private final Schema f9480; + private final Schema f9490; + private final Schema f9500; + private final Schema f9510; + private final Schema f9520; + private final Schema f9530; + private final Schema f9540; + private final Schema f9550; + private final Schema f9560; + private final Schema f9570; + private final Schema f9580; + private final Schema f9590; + private final Schema f9600; + private final Schema f9610; + private final Schema f9620; + private final Schema f9630; + private final Schema f9640; + private final Schema f9650; + private final Schema f9660; + private final Schema f9670; + private final Schema f9680; + private final Schema f9690; + private final Schema f9700; + private final Schema f9710; + private final Schema f9720; + private final Schema f9730; + private final Schema f9740; + private final Schema f9750; + private final Schema f9760; + private final Schema f9770; + private final Schema f9780; + private final Schema f9790; + private final Schema f9800; + private final Schema f9810; + private final Schema f9820; + private final Schema f9830; + private final Schema f9840; + private final Schema f9850; + private final Schema f9860; + private final Schema f9870; + private final Schema f9880; + private final Schema f9890; + private final Schema f9900; + private final Schema f9910; + private final Schema f9920; + private final Schema f9930; + private final Schema f9940; + private final Schema f9950; + private final Schema f9960; + private final Schema f9970; + private final Schema f9980; + private final Schema f9990; + + public FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema_GenericDeserializer_836892732_836892732(Schema readerSchema) { + this.readerSchema = readerSchema; + this.f00 = readerSchema.getField("F0").schema(); + this.f10 = readerSchema.getField("F1").schema(); + this.f20 = readerSchema.getField("F2").schema(); + this.f30 = readerSchema.getField("F3").schema(); + this.f40 = readerSchema.getField("F4").schema(); + this.f50 = readerSchema.getField("F5").schema(); + this.f60 = readerSchema.getField("F6").schema(); + this.f70 = readerSchema.getField("F7").schema(); + this.f80 = readerSchema.getField("F8").schema(); + this.f90 = readerSchema.getField("F9").schema(); + this.f100 = readerSchema.getField("F10").schema(); + this.f110 = readerSchema.getField("F11").schema(); + this.f120 = readerSchema.getField("F12").schema(); + this.f130 = readerSchema.getField("F13").schema(); + this.f140 = readerSchema.getField("F14").schema(); + this.f150 = readerSchema.getField("F15").schema(); + this.f160 = readerSchema.getField("F16").schema(); + this.f170 = readerSchema.getField("F17").schema(); + this.f180 = readerSchema.getField("F18").schema(); + this.f190 = readerSchema.getField("F19").schema(); + this.f200 = readerSchema.getField("F20").schema(); + this.f210 = readerSchema.getField("F21").schema(); + this.f220 = readerSchema.getField("F22").schema(); + this.f230 = readerSchema.getField("F23").schema(); + this.f240 = readerSchema.getField("F24").schema(); + this.f250 = readerSchema.getField("F25").schema(); + this.f260 = readerSchema.getField("F26").schema(); + this.f270 = readerSchema.getField("F27").schema(); + this.f280 = readerSchema.getField("F28").schema(); + this.f290 = readerSchema.getField("F29").schema(); + this.f300 = readerSchema.getField("F30").schema(); + this.f310 = readerSchema.getField("F31").schema(); + this.f320 = readerSchema.getField("F32").schema(); + this.f330 = readerSchema.getField("F33").schema(); + this.f340 = readerSchema.getField("F34").schema(); + this.f350 = readerSchema.getField("F35").schema(); + this.f360 = readerSchema.getField("F36").schema(); + this.f370 = readerSchema.getField("F37").schema(); + this.f380 = readerSchema.getField("F38").schema(); + this.f390 = readerSchema.getField("F39").schema(); + this.f400 = readerSchema.getField("F40").schema(); + this.f410 = readerSchema.getField("F41").schema(); + this.f420 = readerSchema.getField("F42").schema(); + this.f430 = readerSchema.getField("F43").schema(); + this.f440 = readerSchema.getField("F44").schema(); + this.f450 = readerSchema.getField("F45").schema(); + this.f460 = readerSchema.getField("F46").schema(); + this.f470 = readerSchema.getField("F47").schema(); + this.f480 = readerSchema.getField("F48").schema(); + this.f490 = readerSchema.getField("F49").schema(); + this.f500 = readerSchema.getField("F50").schema(); + this.f510 = readerSchema.getField("F51").schema(); + this.f520 = readerSchema.getField("F52").schema(); + this.f530 = readerSchema.getField("F53").schema(); + this.f540 = readerSchema.getField("F54").schema(); + this.f550 = readerSchema.getField("F55").schema(); + this.f560 = readerSchema.getField("F56").schema(); + this.f570 = readerSchema.getField("F57").schema(); + this.f580 = readerSchema.getField("F58").schema(); + this.f590 = readerSchema.getField("F59").schema(); + this.f600 = readerSchema.getField("F60").schema(); + this.f610 = readerSchema.getField("F61").schema(); + this.f620 = readerSchema.getField("F62").schema(); + this.f630 = readerSchema.getField("F63").schema(); + this.f640 = readerSchema.getField("F64").schema(); + this.f650 = readerSchema.getField("F65").schema(); + this.f660 = readerSchema.getField("F66").schema(); + this.f670 = readerSchema.getField("F67").schema(); + this.f680 = readerSchema.getField("F68").schema(); + this.f690 = readerSchema.getField("F69").schema(); + this.f700 = readerSchema.getField("F70").schema(); + this.f710 = readerSchema.getField("F71").schema(); + this.f720 = readerSchema.getField("F72").schema(); + this.f730 = readerSchema.getField("F73").schema(); + this.f740 = readerSchema.getField("F74").schema(); + this.f750 = readerSchema.getField("F75").schema(); + this.f760 = readerSchema.getField("F76").schema(); + this.f770 = readerSchema.getField("F77").schema(); + this.f780 = readerSchema.getField("F78").schema(); + this.f790 = readerSchema.getField("F79").schema(); + this.f800 = readerSchema.getField("F80").schema(); + this.f810 = readerSchema.getField("F81").schema(); + this.f820 = readerSchema.getField("F82").schema(); + this.f830 = readerSchema.getField("F83").schema(); + this.f840 = readerSchema.getField("F84").schema(); + this.f850 = readerSchema.getField("F85").schema(); + this.f860 = readerSchema.getField("F86").schema(); + this.f870 = readerSchema.getField("F87").schema(); + this.f880 = readerSchema.getField("F88").schema(); + this.f890 = readerSchema.getField("F89").schema(); + this.f900 = readerSchema.getField("F90").schema(); + this.f910 = readerSchema.getField("F91").schema(); + this.f920 = readerSchema.getField("F92").schema(); + this.f930 = readerSchema.getField("F93").schema(); + this.f940 = readerSchema.getField("F94").schema(); + this.f950 = readerSchema.getField("F95").schema(); + this.f960 = readerSchema.getField("F96").schema(); + this.f970 = readerSchema.getField("F97").schema(); + this.f980 = readerSchema.getField("F98").schema(); + this.f990 = readerSchema.getField("F99").schema(); + this.f1000 = readerSchema.getField("F100").schema(); + this.f1010 = readerSchema.getField("F101").schema(); + this.f1020 = readerSchema.getField("F102").schema(); + this.f1030 = readerSchema.getField("F103").schema(); + this.f1040 = readerSchema.getField("F104").schema(); + this.f1050 = readerSchema.getField("F105").schema(); + this.f1060 = readerSchema.getField("F106").schema(); + this.f1070 = readerSchema.getField("F107").schema(); + this.f1080 = readerSchema.getField("F108").schema(); + this.f1090 = readerSchema.getField("F109").schema(); + this.f1100 = readerSchema.getField("F110").schema(); + this.f1110 = readerSchema.getField("F111").schema(); + this.f1120 = readerSchema.getField("F112").schema(); + this.f1130 = readerSchema.getField("F113").schema(); + this.f1140 = readerSchema.getField("F114").schema(); + this.f1150 = readerSchema.getField("F115").schema(); + this.f1160 = readerSchema.getField("F116").schema(); + this.f1170 = readerSchema.getField("F117").schema(); + this.f1180 = readerSchema.getField("F118").schema(); + this.f1190 = readerSchema.getField("F119").schema(); + this.f1200 = readerSchema.getField("F120").schema(); + this.f1210 = readerSchema.getField("F121").schema(); + this.f1220 = readerSchema.getField("F122").schema(); + this.f1230 = readerSchema.getField("F123").schema(); + this.f1240 = readerSchema.getField("F124").schema(); + this.f1250 = readerSchema.getField("F125").schema(); + this.f1260 = readerSchema.getField("F126").schema(); + this.f1270 = readerSchema.getField("F127").schema(); + this.f1280 = readerSchema.getField("F128").schema(); + this.f1290 = readerSchema.getField("F129").schema(); + this.f1300 = readerSchema.getField("F130").schema(); + this.f1310 = readerSchema.getField("F131").schema(); + this.f1320 = readerSchema.getField("F132").schema(); + this.f1330 = readerSchema.getField("F133").schema(); + this.f1340 = readerSchema.getField("F134").schema(); + this.f1350 = readerSchema.getField("F135").schema(); + this.f1360 = readerSchema.getField("F136").schema(); + this.f1370 = readerSchema.getField("F137").schema(); + this.f1380 = readerSchema.getField("F138").schema(); + this.f1390 = readerSchema.getField("F139").schema(); + this.f1400 = readerSchema.getField("F140").schema(); + this.f1410 = readerSchema.getField("F141").schema(); + this.f1420 = readerSchema.getField("F142").schema(); + this.f1430 = readerSchema.getField("F143").schema(); + this.f1440 = readerSchema.getField("F144").schema(); + this.f1450 = readerSchema.getField("F145").schema(); + this.f1460 = readerSchema.getField("F146").schema(); + this.f1470 = readerSchema.getField("F147").schema(); + this.f1480 = readerSchema.getField("F148").schema(); + this.f1490 = readerSchema.getField("F149").schema(); + this.f1500 = readerSchema.getField("F150").schema(); + this.f1510 = readerSchema.getField("F151").schema(); + this.f1520 = readerSchema.getField("F152").schema(); + this.f1530 = readerSchema.getField("F153").schema(); + this.f1540 = readerSchema.getField("F154").schema(); + this.f1550 = readerSchema.getField("F155").schema(); + this.f1560 = readerSchema.getField("F156").schema(); + this.f1570 = readerSchema.getField("F157").schema(); + this.f1580 = readerSchema.getField("F158").schema(); + this.f1590 = readerSchema.getField("F159").schema(); + this.f1600 = readerSchema.getField("F160").schema(); + this.f1610 = readerSchema.getField("F161").schema(); + this.f1620 = readerSchema.getField("F162").schema(); + this.f1630 = readerSchema.getField("F163").schema(); + this.f1640 = readerSchema.getField("F164").schema(); + this.f1650 = readerSchema.getField("F165").schema(); + this.f1660 = readerSchema.getField("F166").schema(); + this.f1670 = readerSchema.getField("F167").schema(); + this.f1680 = readerSchema.getField("F168").schema(); + this.f1690 = readerSchema.getField("F169").schema(); + this.f1700 = readerSchema.getField("F170").schema(); + this.f1710 = readerSchema.getField("F171").schema(); + this.f1720 = readerSchema.getField("F172").schema(); + this.f1730 = readerSchema.getField("F173").schema(); + this.f1740 = readerSchema.getField("F174").schema(); + this.f1750 = readerSchema.getField("F175").schema(); + this.f1760 = readerSchema.getField("F176").schema(); + this.f1770 = readerSchema.getField("F177").schema(); + this.f1780 = readerSchema.getField("F178").schema(); + this.f1790 = readerSchema.getField("F179").schema(); + this.f1800 = readerSchema.getField("F180").schema(); + this.f1810 = readerSchema.getField("F181").schema(); + this.f1820 = readerSchema.getField("F182").schema(); + this.f1830 = readerSchema.getField("F183").schema(); + this.f1840 = readerSchema.getField("F184").schema(); + this.f1850 = readerSchema.getField("F185").schema(); + this.f1860 = readerSchema.getField("F186").schema(); + this.f1870 = readerSchema.getField("F187").schema(); + this.f1880 = readerSchema.getField("F188").schema(); + this.f1890 = readerSchema.getField("F189").schema(); + this.f1900 = readerSchema.getField("F190").schema(); + this.f1910 = readerSchema.getField("F191").schema(); + this.f1920 = readerSchema.getField("F192").schema(); + this.f1930 = readerSchema.getField("F193").schema(); + this.f1940 = readerSchema.getField("F194").schema(); + this.f1950 = readerSchema.getField("F195").schema(); + this.f1960 = readerSchema.getField("F196").schema(); + this.f1970 = readerSchema.getField("F197").schema(); + this.f1980 = readerSchema.getField("F198").schema(); + this.f1990 = readerSchema.getField("F199").schema(); + this.f2000 = readerSchema.getField("F200").schema(); + this.f2010 = readerSchema.getField("F201").schema(); + this.f2020 = readerSchema.getField("F202").schema(); + this.f2030 = readerSchema.getField("F203").schema(); + this.f2040 = readerSchema.getField("F204").schema(); + this.f2050 = readerSchema.getField("F205").schema(); + this.f2060 = readerSchema.getField("F206").schema(); + this.f2070 = readerSchema.getField("F207").schema(); + this.f2080 = readerSchema.getField("F208").schema(); + this.f2090 = readerSchema.getField("F209").schema(); + this.f2100 = readerSchema.getField("F210").schema(); + this.f2110 = readerSchema.getField("F211").schema(); + this.f2120 = readerSchema.getField("F212").schema(); + this.f2130 = readerSchema.getField("F213").schema(); + this.f2140 = readerSchema.getField("F214").schema(); + this.f2150 = readerSchema.getField("F215").schema(); + this.f2160 = readerSchema.getField("F216").schema(); + this.f2170 = readerSchema.getField("F217").schema(); + this.f2180 = readerSchema.getField("F218").schema(); + this.f2190 = readerSchema.getField("F219").schema(); + this.f2200 = readerSchema.getField("F220").schema(); + this.f2210 = readerSchema.getField("F221").schema(); + this.f2220 = readerSchema.getField("F222").schema(); + this.f2230 = readerSchema.getField("F223").schema(); + this.f2240 = readerSchema.getField("F224").schema(); + this.f2250 = readerSchema.getField("F225").schema(); + this.f2260 = readerSchema.getField("F226").schema(); + this.f2270 = readerSchema.getField("F227").schema(); + this.f2280 = readerSchema.getField("F228").schema(); + this.f2290 = readerSchema.getField("F229").schema(); + this.f2300 = readerSchema.getField("F230").schema(); + this.f2310 = readerSchema.getField("F231").schema(); + this.f2320 = readerSchema.getField("F232").schema(); + this.f2330 = readerSchema.getField("F233").schema(); + this.f2340 = readerSchema.getField("F234").schema(); + this.f2350 = readerSchema.getField("F235").schema(); + this.f2360 = readerSchema.getField("F236").schema(); + this.f2370 = readerSchema.getField("F237").schema(); + this.f2380 = readerSchema.getField("F238").schema(); + this.f2390 = readerSchema.getField("F239").schema(); + this.f2400 = readerSchema.getField("F240").schema(); + this.f2410 = readerSchema.getField("F241").schema(); + this.f2420 = readerSchema.getField("F242").schema(); + this.f2430 = readerSchema.getField("F243").schema(); + this.f2440 = readerSchema.getField("F244").schema(); + this.f2450 = readerSchema.getField("F245").schema(); + this.f2460 = readerSchema.getField("F246").schema(); + this.f2470 = readerSchema.getField("F247").schema(); + this.f2480 = readerSchema.getField("F248").schema(); + this.f2490 = readerSchema.getField("F249").schema(); + this.f2500 = readerSchema.getField("F250").schema(); + this.f2510 = readerSchema.getField("F251").schema(); + this.f2520 = readerSchema.getField("F252").schema(); + this.f2530 = readerSchema.getField("F253").schema(); + this.f2540 = readerSchema.getField("F254").schema(); + this.f2550 = readerSchema.getField("F255").schema(); + this.f2560 = readerSchema.getField("F256").schema(); + this.f2570 = readerSchema.getField("F257").schema(); + this.f2580 = readerSchema.getField("F258").schema(); + this.f2590 = readerSchema.getField("F259").schema(); + this.f2600 = readerSchema.getField("F260").schema(); + this.f2610 = readerSchema.getField("F261").schema(); + this.f2620 = readerSchema.getField("F262").schema(); + this.f2630 = readerSchema.getField("F263").schema(); + this.f2640 = readerSchema.getField("F264").schema(); + this.f2650 = readerSchema.getField("F265").schema(); + this.f2660 = readerSchema.getField("F266").schema(); + this.f2670 = readerSchema.getField("F267").schema(); + this.f2680 = readerSchema.getField("F268").schema(); + this.f2690 = readerSchema.getField("F269").schema(); + this.f2700 = readerSchema.getField("F270").schema(); + this.f2710 = readerSchema.getField("F271").schema(); + this.f2720 = readerSchema.getField("F272").schema(); + this.f2730 = readerSchema.getField("F273").schema(); + this.f2740 = readerSchema.getField("F274").schema(); + this.f2750 = readerSchema.getField("F275").schema(); + this.f2760 = readerSchema.getField("F276").schema(); + this.f2770 = readerSchema.getField("F277").schema(); + this.f2780 = readerSchema.getField("F278").schema(); + this.f2790 = readerSchema.getField("F279").schema(); + this.f2800 = readerSchema.getField("F280").schema(); + this.f2810 = readerSchema.getField("F281").schema(); + this.f2820 = readerSchema.getField("F282").schema(); + this.f2830 = readerSchema.getField("F283").schema(); + this.f2840 = readerSchema.getField("F284").schema(); + this.f2850 = readerSchema.getField("F285").schema(); + this.f2860 = readerSchema.getField("F286").schema(); + this.f2870 = readerSchema.getField("F287").schema(); + this.f2880 = readerSchema.getField("F288").schema(); + this.f2890 = readerSchema.getField("F289").schema(); + this.f2900 = readerSchema.getField("F290").schema(); + this.f2910 = readerSchema.getField("F291").schema(); + this.f2920 = readerSchema.getField("F292").schema(); + this.f2930 = readerSchema.getField("F293").schema(); + this.f2940 = readerSchema.getField("F294").schema(); + this.f2950 = readerSchema.getField("F295").schema(); + this.f2960 = readerSchema.getField("F296").schema(); + this.f2970 = readerSchema.getField("F297").schema(); + this.f2980 = readerSchema.getField("F298").schema(); + this.f2990 = readerSchema.getField("F299").schema(); + this.f3000 = readerSchema.getField("F300").schema(); + this.f3010 = readerSchema.getField("F301").schema(); + this.f3020 = readerSchema.getField("F302").schema(); + this.f3030 = readerSchema.getField("F303").schema(); + this.f3040 = readerSchema.getField("F304").schema(); + this.f3050 = readerSchema.getField("F305").schema(); + this.f3060 = readerSchema.getField("F306").schema(); + this.f3070 = readerSchema.getField("F307").schema(); + this.f3080 = readerSchema.getField("F308").schema(); + this.f3090 = readerSchema.getField("F309").schema(); + this.f3100 = readerSchema.getField("F310").schema(); + this.f3110 = readerSchema.getField("F311").schema(); + this.f3120 = readerSchema.getField("F312").schema(); + this.f3130 = readerSchema.getField("F313").schema(); + this.f3140 = readerSchema.getField("F314").schema(); + this.f3150 = readerSchema.getField("F315").schema(); + this.f3160 = readerSchema.getField("F316").schema(); + this.f3170 = readerSchema.getField("F317").schema(); + this.f3180 = readerSchema.getField("F318").schema(); + this.f3190 = readerSchema.getField("F319").schema(); + this.f3200 = readerSchema.getField("F320").schema(); + this.f3210 = readerSchema.getField("F321").schema(); + this.f3220 = readerSchema.getField("F322").schema(); + this.f3230 = readerSchema.getField("F323").schema(); + this.f3240 = readerSchema.getField("F324").schema(); + this.f3250 = readerSchema.getField("F325").schema(); + this.f3260 = readerSchema.getField("F326").schema(); + this.f3270 = readerSchema.getField("F327").schema(); + this.f3280 = readerSchema.getField("F328").schema(); + this.f3290 = readerSchema.getField("F329").schema(); + this.f3300 = readerSchema.getField("F330").schema(); + this.f3310 = readerSchema.getField("F331").schema(); + this.f3320 = readerSchema.getField("F332").schema(); + this.f3330 = readerSchema.getField("F333").schema(); + this.f3340 = readerSchema.getField("F334").schema(); + this.f3350 = readerSchema.getField("F335").schema(); + this.f3360 = readerSchema.getField("F336").schema(); + this.f3370 = readerSchema.getField("F337").schema(); + this.f3380 = readerSchema.getField("F338").schema(); + this.f3390 = readerSchema.getField("F339").schema(); + this.f3400 = readerSchema.getField("F340").schema(); + this.f3410 = readerSchema.getField("F341").schema(); + this.f3420 = readerSchema.getField("F342").schema(); + this.f3430 = readerSchema.getField("F343").schema(); + this.f3440 = readerSchema.getField("F344").schema(); + this.f3450 = readerSchema.getField("F345").schema(); + this.f3460 = readerSchema.getField("F346").schema(); + this.f3470 = readerSchema.getField("F347").schema(); + this.f3480 = readerSchema.getField("F348").schema(); + this.f3490 = readerSchema.getField("F349").schema(); + this.f3500 = readerSchema.getField("F350").schema(); + this.f3510 = readerSchema.getField("F351").schema(); + this.f3520 = readerSchema.getField("F352").schema(); + this.f3530 = readerSchema.getField("F353").schema(); + this.f3540 = readerSchema.getField("F354").schema(); + this.f3550 = readerSchema.getField("F355").schema(); + this.f3560 = readerSchema.getField("F356").schema(); + this.f3570 = readerSchema.getField("F357").schema(); + this.f3580 = readerSchema.getField("F358").schema(); + this.f3590 = readerSchema.getField("F359").schema(); + this.f3600 = readerSchema.getField("F360").schema(); + this.f3610 = readerSchema.getField("F361").schema(); + this.f3620 = readerSchema.getField("F362").schema(); + this.f3630 = readerSchema.getField("F363").schema(); + this.f3640 = readerSchema.getField("F364").schema(); + this.f3650 = readerSchema.getField("F365").schema(); + this.f3660 = readerSchema.getField("F366").schema(); + this.f3670 = readerSchema.getField("F367").schema(); + this.f3680 = readerSchema.getField("F368").schema(); + this.f3690 = readerSchema.getField("F369").schema(); + this.f3700 = readerSchema.getField("F370").schema(); + this.f3710 = readerSchema.getField("F371").schema(); + this.f3720 = readerSchema.getField("F372").schema(); + this.f3730 = readerSchema.getField("F373").schema(); + this.f3740 = readerSchema.getField("F374").schema(); + this.f3750 = readerSchema.getField("F375").schema(); + this.f3760 = readerSchema.getField("F376").schema(); + this.f3770 = readerSchema.getField("F377").schema(); + this.f3780 = readerSchema.getField("F378").schema(); + this.f3790 = readerSchema.getField("F379").schema(); + this.f3800 = readerSchema.getField("F380").schema(); + this.f3810 = readerSchema.getField("F381").schema(); + this.f3820 = readerSchema.getField("F382").schema(); + this.f3830 = readerSchema.getField("F383").schema(); + this.f3840 = readerSchema.getField("F384").schema(); + this.f3850 = readerSchema.getField("F385").schema(); + this.f3860 = readerSchema.getField("F386").schema(); + this.f3870 = readerSchema.getField("F387").schema(); + this.f3880 = readerSchema.getField("F388").schema(); + this.f3890 = readerSchema.getField("F389").schema(); + this.f3900 = readerSchema.getField("F390").schema(); + this.f3910 = readerSchema.getField("F391").schema(); + this.f3920 = readerSchema.getField("F392").schema(); + this.f3930 = readerSchema.getField("F393").schema(); + this.f3940 = readerSchema.getField("F394").schema(); + this.f3950 = readerSchema.getField("F395").schema(); + this.f3960 = readerSchema.getField("F396").schema(); + this.f3970 = readerSchema.getField("F397").schema(); + this.f3980 = readerSchema.getField("F398").schema(); + this.f3990 = readerSchema.getField("F399").schema(); + this.f4000 = readerSchema.getField("F400").schema(); + this.f4010 = readerSchema.getField("F401").schema(); + this.f4020 = readerSchema.getField("F402").schema(); + this.f4030 = readerSchema.getField("F403").schema(); + this.f4040 = readerSchema.getField("F404").schema(); + this.f4050 = readerSchema.getField("F405").schema(); + this.f4060 = readerSchema.getField("F406").schema(); + this.f4070 = readerSchema.getField("F407").schema(); + this.f4080 = readerSchema.getField("F408").schema(); + this.f4090 = readerSchema.getField("F409").schema(); + this.f4100 = readerSchema.getField("F410").schema(); + this.f4110 = readerSchema.getField("F411").schema(); + this.f4120 = readerSchema.getField("F412").schema(); + this.f4130 = readerSchema.getField("F413").schema(); + this.f4140 = readerSchema.getField("F414").schema(); + this.f4150 = readerSchema.getField("F415").schema(); + this.f4160 = readerSchema.getField("F416").schema(); + this.f4170 = readerSchema.getField("F417").schema(); + this.f4180 = readerSchema.getField("F418").schema(); + this.f4190 = readerSchema.getField("F419").schema(); + this.f4200 = readerSchema.getField("F420").schema(); + this.f4210 = readerSchema.getField("F421").schema(); + this.f4220 = readerSchema.getField("F422").schema(); + this.f4230 = readerSchema.getField("F423").schema(); + this.f4240 = readerSchema.getField("F424").schema(); + this.f4250 = readerSchema.getField("F425").schema(); + this.f4260 = readerSchema.getField("F426").schema(); + this.f4270 = readerSchema.getField("F427").schema(); + this.f4280 = readerSchema.getField("F428").schema(); + this.f4290 = readerSchema.getField("F429").schema(); + this.f4300 = readerSchema.getField("F430").schema(); + this.f4310 = readerSchema.getField("F431").schema(); + this.f4320 = readerSchema.getField("F432").schema(); + this.f4330 = readerSchema.getField("F433").schema(); + this.f4340 = readerSchema.getField("F434").schema(); + this.f4350 = readerSchema.getField("F435").schema(); + this.f4360 = readerSchema.getField("F436").schema(); + this.f4370 = readerSchema.getField("F437").schema(); + this.f4380 = readerSchema.getField("F438").schema(); + this.f4390 = readerSchema.getField("F439").schema(); + this.f4400 = readerSchema.getField("F440").schema(); + this.f4410 = readerSchema.getField("F441").schema(); + this.f4420 = readerSchema.getField("F442").schema(); + this.f4430 = readerSchema.getField("F443").schema(); + this.f4440 = readerSchema.getField("F444").schema(); + this.f4450 = readerSchema.getField("F445").schema(); + this.f4460 = readerSchema.getField("F446").schema(); + this.f4470 = readerSchema.getField("F447").schema(); + this.f4480 = readerSchema.getField("F448").schema(); + this.f4490 = readerSchema.getField("F449").schema(); + this.f4500 = readerSchema.getField("F450").schema(); + this.f4510 = readerSchema.getField("F451").schema(); + this.f4520 = readerSchema.getField("F452").schema(); + this.f4530 = readerSchema.getField("F453").schema(); + this.f4540 = readerSchema.getField("F454").schema(); + this.f4550 = readerSchema.getField("F455").schema(); + this.f4560 = readerSchema.getField("F456").schema(); + this.f4570 = readerSchema.getField("F457").schema(); + this.f4580 = readerSchema.getField("F458").schema(); + this.f4590 = readerSchema.getField("F459").schema(); + this.f4600 = readerSchema.getField("F460").schema(); + this.f4610 = readerSchema.getField("F461").schema(); + this.f4620 = readerSchema.getField("F462").schema(); + this.f4630 = readerSchema.getField("F463").schema(); + this.f4640 = readerSchema.getField("F464").schema(); + this.f4650 = readerSchema.getField("F465").schema(); + this.f4660 = readerSchema.getField("F466").schema(); + this.f4670 = readerSchema.getField("F467").schema(); + this.f4680 = readerSchema.getField("F468").schema(); + this.f4690 = readerSchema.getField("F469").schema(); + this.f4700 = readerSchema.getField("F470").schema(); + this.f4710 = readerSchema.getField("F471").schema(); + this.f4720 = readerSchema.getField("F472").schema(); + this.f4730 = readerSchema.getField("F473").schema(); + this.f4740 = readerSchema.getField("F474").schema(); + this.f4750 = readerSchema.getField("F475").schema(); + this.f4760 = readerSchema.getField("F476").schema(); + this.f4770 = readerSchema.getField("F477").schema(); + this.f4780 = readerSchema.getField("F478").schema(); + this.f4790 = readerSchema.getField("F479").schema(); + this.f4800 = readerSchema.getField("F480").schema(); + this.f4810 = readerSchema.getField("F481").schema(); + this.f4820 = readerSchema.getField("F482").schema(); + this.f4830 = readerSchema.getField("F483").schema(); + this.f4840 = readerSchema.getField("F484").schema(); + this.f4850 = readerSchema.getField("F485").schema(); + this.f4860 = readerSchema.getField("F486").schema(); + this.f4870 = readerSchema.getField("F487").schema(); + this.f4880 = readerSchema.getField("F488").schema(); + this.f4890 = readerSchema.getField("F489").schema(); + this.f4900 = readerSchema.getField("F490").schema(); + this.f4910 = readerSchema.getField("F491").schema(); + this.f4920 = readerSchema.getField("F492").schema(); + this.f4930 = readerSchema.getField("F493").schema(); + this.f4940 = readerSchema.getField("F494").schema(); + this.f4950 = readerSchema.getField("F495").schema(); + this.f4960 = readerSchema.getField("F496").schema(); + this.f4970 = readerSchema.getField("F497").schema(); + this.f4980 = readerSchema.getField("F498").schema(); + this.f4990 = readerSchema.getField("F499").schema(); + this.f5000 = readerSchema.getField("F500").schema(); + this.f5010 = readerSchema.getField("F501").schema(); + this.f5020 = readerSchema.getField("F502").schema(); + this.f5030 = readerSchema.getField("F503").schema(); + this.f5040 = readerSchema.getField("F504").schema(); + this.f5050 = readerSchema.getField("F505").schema(); + this.f5060 = readerSchema.getField("F506").schema(); + this.f5070 = readerSchema.getField("F507").schema(); + this.f5080 = readerSchema.getField("F508").schema(); + this.f5090 = readerSchema.getField("F509").schema(); + this.f5100 = readerSchema.getField("F510").schema(); + this.f5110 = readerSchema.getField("F511").schema(); + this.f5120 = readerSchema.getField("F512").schema(); + this.f5130 = readerSchema.getField("F513").schema(); + this.f5140 = readerSchema.getField("F514").schema(); + this.f5150 = readerSchema.getField("F515").schema(); + this.f5160 = readerSchema.getField("F516").schema(); + this.f5170 = readerSchema.getField("F517").schema(); + this.f5180 = readerSchema.getField("F518").schema(); + this.f5190 = readerSchema.getField("F519").schema(); + this.f5200 = readerSchema.getField("F520").schema(); + this.f5210 = readerSchema.getField("F521").schema(); + this.f5220 = readerSchema.getField("F522").schema(); + this.f5230 = readerSchema.getField("F523").schema(); + this.f5240 = readerSchema.getField("F524").schema(); + this.f5250 = readerSchema.getField("F525").schema(); + this.f5260 = readerSchema.getField("F526").schema(); + this.f5270 = readerSchema.getField("F527").schema(); + this.f5280 = readerSchema.getField("F528").schema(); + this.f5290 = readerSchema.getField("F529").schema(); + this.f5300 = readerSchema.getField("F530").schema(); + this.f5310 = readerSchema.getField("F531").schema(); + this.f5320 = readerSchema.getField("F532").schema(); + this.f5330 = readerSchema.getField("F533").schema(); + this.f5340 = readerSchema.getField("F534").schema(); + this.f5350 = readerSchema.getField("F535").schema(); + this.f5360 = readerSchema.getField("F536").schema(); + this.f5370 = readerSchema.getField("F537").schema(); + this.f5380 = readerSchema.getField("F538").schema(); + this.f5390 = readerSchema.getField("F539").schema(); + this.f5400 = readerSchema.getField("F540").schema(); + this.f5410 = readerSchema.getField("F541").schema(); + this.f5420 = readerSchema.getField("F542").schema(); + this.f5430 = readerSchema.getField("F543").schema(); + this.f5440 = readerSchema.getField("F544").schema(); + this.f5450 = readerSchema.getField("F545").schema(); + this.f5460 = readerSchema.getField("F546").schema(); + this.f5470 = readerSchema.getField("F547").schema(); + this.f5480 = readerSchema.getField("F548").schema(); + this.f5490 = readerSchema.getField("F549").schema(); + this.f5500 = readerSchema.getField("F550").schema(); + this.f5510 = readerSchema.getField("F551").schema(); + this.f5520 = readerSchema.getField("F552").schema(); + this.f5530 = readerSchema.getField("F553").schema(); + this.f5540 = readerSchema.getField("F554").schema(); + this.f5550 = readerSchema.getField("F555").schema(); + this.f5560 = readerSchema.getField("F556").schema(); + this.f5570 = readerSchema.getField("F557").schema(); + this.f5580 = readerSchema.getField("F558").schema(); + this.f5590 = readerSchema.getField("F559").schema(); + this.f5600 = readerSchema.getField("F560").schema(); + this.f5610 = readerSchema.getField("F561").schema(); + this.f5620 = readerSchema.getField("F562").schema(); + this.f5630 = readerSchema.getField("F563").schema(); + this.f5640 = readerSchema.getField("F564").schema(); + this.f5650 = readerSchema.getField("F565").schema(); + this.f5660 = readerSchema.getField("F566").schema(); + this.f5670 = readerSchema.getField("F567").schema(); + this.f5680 = readerSchema.getField("F568").schema(); + this.f5690 = readerSchema.getField("F569").schema(); + this.f5700 = readerSchema.getField("F570").schema(); + this.f5710 = readerSchema.getField("F571").schema(); + this.f5720 = readerSchema.getField("F572").schema(); + this.f5730 = readerSchema.getField("F573").schema(); + this.f5740 = readerSchema.getField("F574").schema(); + this.f5750 = readerSchema.getField("F575").schema(); + this.f5760 = readerSchema.getField("F576").schema(); + this.f5770 = readerSchema.getField("F577").schema(); + this.f5780 = readerSchema.getField("F578").schema(); + this.f5790 = readerSchema.getField("F579").schema(); + this.f5800 = readerSchema.getField("F580").schema(); + this.f5810 = readerSchema.getField("F581").schema(); + this.f5820 = readerSchema.getField("F582").schema(); + this.f5830 = readerSchema.getField("F583").schema(); + this.f5840 = readerSchema.getField("F584").schema(); + this.f5850 = readerSchema.getField("F585").schema(); + this.f5860 = readerSchema.getField("F586").schema(); + this.f5870 = readerSchema.getField("F587").schema(); + this.f5880 = readerSchema.getField("F588").schema(); + this.f5890 = readerSchema.getField("F589").schema(); + this.f5900 = readerSchema.getField("F590").schema(); + this.f5910 = readerSchema.getField("F591").schema(); + this.f5920 = readerSchema.getField("F592").schema(); + this.f5930 = readerSchema.getField("F593").schema(); + this.f5940 = readerSchema.getField("F594").schema(); + this.f5950 = readerSchema.getField("F595").schema(); + this.f5960 = readerSchema.getField("F596").schema(); + this.f5970 = readerSchema.getField("F597").schema(); + this.f5980 = readerSchema.getField("F598").schema(); + this.f5990 = readerSchema.getField("F599").schema(); + this.f6000 = readerSchema.getField("F600").schema(); + this.f6010 = readerSchema.getField("F601").schema(); + this.f6020 = readerSchema.getField("F602").schema(); + this.f6030 = readerSchema.getField("F603").schema(); + this.f6040 = readerSchema.getField("F604").schema(); + this.f6050 = readerSchema.getField("F605").schema(); + this.f6060 = readerSchema.getField("F606").schema(); + this.f6070 = readerSchema.getField("F607").schema(); + this.f6080 = readerSchema.getField("F608").schema(); + this.f6090 = readerSchema.getField("F609").schema(); + this.f6100 = readerSchema.getField("F610").schema(); + this.f6110 = readerSchema.getField("F611").schema(); + this.f6120 = readerSchema.getField("F612").schema(); + this.f6130 = readerSchema.getField("F613").schema(); + this.f6140 = readerSchema.getField("F614").schema(); + this.f6150 = readerSchema.getField("F615").schema(); + this.f6160 = readerSchema.getField("F616").schema(); + this.f6170 = readerSchema.getField("F617").schema(); + this.f6180 = readerSchema.getField("F618").schema(); + this.f6190 = readerSchema.getField("F619").schema(); + this.f6200 = readerSchema.getField("F620").schema(); + this.f6210 = readerSchema.getField("F621").schema(); + this.f6220 = readerSchema.getField("F622").schema(); + this.f6230 = readerSchema.getField("F623").schema(); + this.f6240 = readerSchema.getField("F624").schema(); + this.f6250 = readerSchema.getField("F625").schema(); + this.f6260 = readerSchema.getField("F626").schema(); + this.f6270 = readerSchema.getField("F627").schema(); + this.f6280 = readerSchema.getField("F628").schema(); + this.f6290 = readerSchema.getField("F629").schema(); + this.f6300 = readerSchema.getField("F630").schema(); + this.f6310 = readerSchema.getField("F631").schema(); + this.f6320 = readerSchema.getField("F632").schema(); + this.f6330 = readerSchema.getField("F633").schema(); + this.f6340 = readerSchema.getField("F634").schema(); + this.f6350 = readerSchema.getField("F635").schema(); + this.f6360 = readerSchema.getField("F636").schema(); + this.f6370 = readerSchema.getField("F637").schema(); + this.f6380 = readerSchema.getField("F638").schema(); + this.f6390 = readerSchema.getField("F639").schema(); + this.f6400 = readerSchema.getField("F640").schema(); + this.f6410 = readerSchema.getField("F641").schema(); + this.f6420 = readerSchema.getField("F642").schema(); + this.f6430 = readerSchema.getField("F643").schema(); + this.f6440 = readerSchema.getField("F644").schema(); + this.f6450 = readerSchema.getField("F645").schema(); + this.f6460 = readerSchema.getField("F646").schema(); + this.f6470 = readerSchema.getField("F647").schema(); + this.f6480 = readerSchema.getField("F648").schema(); + this.f6490 = readerSchema.getField("F649").schema(); + this.f6500 = readerSchema.getField("F650").schema(); + this.f6510 = readerSchema.getField("F651").schema(); + this.f6520 = readerSchema.getField("F652").schema(); + this.f6530 = readerSchema.getField("F653").schema(); + this.f6540 = readerSchema.getField("F654").schema(); + this.f6550 = readerSchema.getField("F655").schema(); + this.f6560 = readerSchema.getField("F656").schema(); + this.f6570 = readerSchema.getField("F657").schema(); + this.f6580 = readerSchema.getField("F658").schema(); + this.f6590 = readerSchema.getField("F659").schema(); + this.f6600 = readerSchema.getField("F660").schema(); + this.f6610 = readerSchema.getField("F661").schema(); + this.f6620 = readerSchema.getField("F662").schema(); + this.f6630 = readerSchema.getField("F663").schema(); + this.f6640 = readerSchema.getField("F664").schema(); + this.f6650 = readerSchema.getField("F665").schema(); + this.f6660 = readerSchema.getField("F666").schema(); + this.f6670 = readerSchema.getField("F667").schema(); + this.f6680 = readerSchema.getField("F668").schema(); + this.f6690 = readerSchema.getField("F669").schema(); + this.f6700 = readerSchema.getField("F670").schema(); + this.f6710 = readerSchema.getField("F671").schema(); + this.f6720 = readerSchema.getField("F672").schema(); + this.f6730 = readerSchema.getField("F673").schema(); + this.f6740 = readerSchema.getField("F674").schema(); + this.f6750 = readerSchema.getField("F675").schema(); + this.f6760 = readerSchema.getField("F676").schema(); + this.f6770 = readerSchema.getField("F677").schema(); + this.f6780 = readerSchema.getField("F678").schema(); + this.f6790 = readerSchema.getField("F679").schema(); + this.f6800 = readerSchema.getField("F680").schema(); + this.f6810 = readerSchema.getField("F681").schema(); + this.f6820 = readerSchema.getField("F682").schema(); + this.f6830 = readerSchema.getField("F683").schema(); + this.f6840 = readerSchema.getField("F684").schema(); + this.f6850 = readerSchema.getField("F685").schema(); + this.f6860 = readerSchema.getField("F686").schema(); + this.f6870 = readerSchema.getField("F687").schema(); + this.f6880 = readerSchema.getField("F688").schema(); + this.f6890 = readerSchema.getField("F689").schema(); + this.f6900 = readerSchema.getField("F690").schema(); + this.f6910 = readerSchema.getField("F691").schema(); + this.f6920 = readerSchema.getField("F692").schema(); + this.f6930 = readerSchema.getField("F693").schema(); + this.f6940 = readerSchema.getField("F694").schema(); + this.f6950 = readerSchema.getField("F695").schema(); + this.f6960 = readerSchema.getField("F696").schema(); + this.f6970 = readerSchema.getField("F697").schema(); + this.f6980 = readerSchema.getField("F698").schema(); + this.f6990 = readerSchema.getField("F699").schema(); + this.f7000 = readerSchema.getField("F700").schema(); + this.f7010 = readerSchema.getField("F701").schema(); + this.f7020 = readerSchema.getField("F702").schema(); + this.f7030 = readerSchema.getField("F703").schema(); + this.f7040 = readerSchema.getField("F704").schema(); + this.f7050 = readerSchema.getField("F705").schema(); + this.f7060 = readerSchema.getField("F706").schema(); + this.f7070 = readerSchema.getField("F707").schema(); + this.f7080 = readerSchema.getField("F708").schema(); + this.f7090 = readerSchema.getField("F709").schema(); + this.f7100 = readerSchema.getField("F710").schema(); + this.f7110 = readerSchema.getField("F711").schema(); + this.f7120 = readerSchema.getField("F712").schema(); + this.f7130 = readerSchema.getField("F713").schema(); + this.f7140 = readerSchema.getField("F714").schema(); + this.f7150 = readerSchema.getField("F715").schema(); + this.f7160 = readerSchema.getField("F716").schema(); + this.f7170 = readerSchema.getField("F717").schema(); + this.f7180 = readerSchema.getField("F718").schema(); + this.f7190 = readerSchema.getField("F719").schema(); + this.f7200 = readerSchema.getField("F720").schema(); + this.f7210 = readerSchema.getField("F721").schema(); + this.f7220 = readerSchema.getField("F722").schema(); + this.f7230 = readerSchema.getField("F723").schema(); + this.f7240 = readerSchema.getField("F724").schema(); + this.f7250 = readerSchema.getField("F725").schema(); + this.f7260 = readerSchema.getField("F726").schema(); + this.f7270 = readerSchema.getField("F727").schema(); + this.f7280 = readerSchema.getField("F728").schema(); + this.f7290 = readerSchema.getField("F729").schema(); + this.f7300 = readerSchema.getField("F730").schema(); + this.f7310 = readerSchema.getField("F731").schema(); + this.f7320 = readerSchema.getField("F732").schema(); + this.f7330 = readerSchema.getField("F733").schema(); + this.f7340 = readerSchema.getField("F734").schema(); + this.f7350 = readerSchema.getField("F735").schema(); + this.f7360 = readerSchema.getField("F736").schema(); + this.f7370 = readerSchema.getField("F737").schema(); + this.f7380 = readerSchema.getField("F738").schema(); + this.f7390 = readerSchema.getField("F739").schema(); + this.f7400 = readerSchema.getField("F740").schema(); + this.f7410 = readerSchema.getField("F741").schema(); + this.f7420 = readerSchema.getField("F742").schema(); + this.f7430 = readerSchema.getField("F743").schema(); + this.f7440 = readerSchema.getField("F744").schema(); + this.f7450 = readerSchema.getField("F745").schema(); + this.f7460 = readerSchema.getField("F746").schema(); + this.f7470 = readerSchema.getField("F747").schema(); + this.f7480 = readerSchema.getField("F748").schema(); + this.f7490 = readerSchema.getField("F749").schema(); + this.f7500 = readerSchema.getField("F750").schema(); + this.f7510 = readerSchema.getField("F751").schema(); + this.f7520 = readerSchema.getField("F752").schema(); + this.f7530 = readerSchema.getField("F753").schema(); + this.f7540 = readerSchema.getField("F754").schema(); + this.f7550 = readerSchema.getField("F755").schema(); + this.f7560 = readerSchema.getField("F756").schema(); + this.f7570 = readerSchema.getField("F757").schema(); + this.f7580 = readerSchema.getField("F758").schema(); + this.f7590 = readerSchema.getField("F759").schema(); + this.f7600 = readerSchema.getField("F760").schema(); + this.f7610 = readerSchema.getField("F761").schema(); + this.f7620 = readerSchema.getField("F762").schema(); + this.f7630 = readerSchema.getField("F763").schema(); + this.f7640 = readerSchema.getField("F764").schema(); + this.f7650 = readerSchema.getField("F765").schema(); + this.f7660 = readerSchema.getField("F766").schema(); + this.f7670 = readerSchema.getField("F767").schema(); + this.f7680 = readerSchema.getField("F768").schema(); + this.f7690 = readerSchema.getField("F769").schema(); + this.f7700 = readerSchema.getField("F770").schema(); + this.f7710 = readerSchema.getField("F771").schema(); + this.f7720 = readerSchema.getField("F772").schema(); + this.f7730 = readerSchema.getField("F773").schema(); + this.f7740 = readerSchema.getField("F774").schema(); + this.f7750 = readerSchema.getField("F775").schema(); + this.f7760 = readerSchema.getField("F776").schema(); + this.f7770 = readerSchema.getField("F777").schema(); + this.f7780 = readerSchema.getField("F778").schema(); + this.f7790 = readerSchema.getField("F779").schema(); + this.f7800 = readerSchema.getField("F780").schema(); + this.f7810 = readerSchema.getField("F781").schema(); + this.f7820 = readerSchema.getField("F782").schema(); + this.f7830 = readerSchema.getField("F783").schema(); + this.f7840 = readerSchema.getField("F784").schema(); + this.f7850 = readerSchema.getField("F785").schema(); + this.f7860 = readerSchema.getField("F786").schema(); + this.f7870 = readerSchema.getField("F787").schema(); + this.f7880 = readerSchema.getField("F788").schema(); + this.f7890 = readerSchema.getField("F789").schema(); + this.f7900 = readerSchema.getField("F790").schema(); + this.f7910 = readerSchema.getField("F791").schema(); + this.f7920 = readerSchema.getField("F792").schema(); + this.f7930 = readerSchema.getField("F793").schema(); + this.f7940 = readerSchema.getField("F794").schema(); + this.f7950 = readerSchema.getField("F795").schema(); + this.f7960 = readerSchema.getField("F796").schema(); + this.f7970 = readerSchema.getField("F797").schema(); + this.f7980 = readerSchema.getField("F798").schema(); + this.f7990 = readerSchema.getField("F799").schema(); + this.f8000 = readerSchema.getField("F800").schema(); + this.f8010 = readerSchema.getField("F801").schema(); + this.f8020 = readerSchema.getField("F802").schema(); + this.f8030 = readerSchema.getField("F803").schema(); + this.f8040 = readerSchema.getField("F804").schema(); + this.f8050 = readerSchema.getField("F805").schema(); + this.f8060 = readerSchema.getField("F806").schema(); + this.f8070 = readerSchema.getField("F807").schema(); + this.f8080 = readerSchema.getField("F808").schema(); + this.f8090 = readerSchema.getField("F809").schema(); + this.f8100 = readerSchema.getField("F810").schema(); + this.f8110 = readerSchema.getField("F811").schema(); + this.f8120 = readerSchema.getField("F812").schema(); + this.f8130 = readerSchema.getField("F813").schema(); + this.f8140 = readerSchema.getField("F814").schema(); + this.f8150 = readerSchema.getField("F815").schema(); + this.f8160 = readerSchema.getField("F816").schema(); + this.f8170 = readerSchema.getField("F817").schema(); + this.f8180 = readerSchema.getField("F818").schema(); + this.f8190 = readerSchema.getField("F819").schema(); + this.f8200 = readerSchema.getField("F820").schema(); + this.f8210 = readerSchema.getField("F821").schema(); + this.f8220 = readerSchema.getField("F822").schema(); + this.f8230 = readerSchema.getField("F823").schema(); + this.f8240 = readerSchema.getField("F824").schema(); + this.f8250 = readerSchema.getField("F825").schema(); + this.f8260 = readerSchema.getField("F826").schema(); + this.f8270 = readerSchema.getField("F827").schema(); + this.f8280 = readerSchema.getField("F828").schema(); + this.f8290 = readerSchema.getField("F829").schema(); + this.f8300 = readerSchema.getField("F830").schema(); + this.f8310 = readerSchema.getField("F831").schema(); + this.f8320 = readerSchema.getField("F832").schema(); + this.f8330 = readerSchema.getField("F833").schema(); + this.f8340 = readerSchema.getField("F834").schema(); + this.f8350 = readerSchema.getField("F835").schema(); + this.f8360 = readerSchema.getField("F836").schema(); + this.f8370 = readerSchema.getField("F837").schema(); + this.f8380 = readerSchema.getField("F838").schema(); + this.f8390 = readerSchema.getField("F839").schema(); + this.f8400 = readerSchema.getField("F840").schema(); + this.f8410 = readerSchema.getField("F841").schema(); + this.f8420 = readerSchema.getField("F842").schema(); + this.f8430 = readerSchema.getField("F843").schema(); + this.f8440 = readerSchema.getField("F844").schema(); + this.f8450 = readerSchema.getField("F845").schema(); + this.f8460 = readerSchema.getField("F846").schema(); + this.f8470 = readerSchema.getField("F847").schema(); + this.f8480 = readerSchema.getField("F848").schema(); + this.f8490 = readerSchema.getField("F849").schema(); + this.f8500 = readerSchema.getField("F850").schema(); + this.f8510 = readerSchema.getField("F851").schema(); + this.f8520 = readerSchema.getField("F852").schema(); + this.f8530 = readerSchema.getField("F853").schema(); + this.f8540 = readerSchema.getField("F854").schema(); + this.f8550 = readerSchema.getField("F855").schema(); + this.f8560 = readerSchema.getField("F856").schema(); + this.f8570 = readerSchema.getField("F857").schema(); + this.f8580 = readerSchema.getField("F858").schema(); + this.f8590 = readerSchema.getField("F859").schema(); + this.f8600 = readerSchema.getField("F860").schema(); + this.f8610 = readerSchema.getField("F861").schema(); + this.f8620 = readerSchema.getField("F862").schema(); + this.f8630 = readerSchema.getField("F863").schema(); + this.f8640 = readerSchema.getField("F864").schema(); + this.f8650 = readerSchema.getField("F865").schema(); + this.f8660 = readerSchema.getField("F866").schema(); + this.f8670 = readerSchema.getField("F867").schema(); + this.f8680 = readerSchema.getField("F868").schema(); + this.f8690 = readerSchema.getField("F869").schema(); + this.f8700 = readerSchema.getField("F870").schema(); + this.f8710 = readerSchema.getField("F871").schema(); + this.f8720 = readerSchema.getField("F872").schema(); + this.f8730 = readerSchema.getField("F873").schema(); + this.f8740 = readerSchema.getField("F874").schema(); + this.f8750 = readerSchema.getField("F875").schema(); + this.f8760 = readerSchema.getField("F876").schema(); + this.f8770 = readerSchema.getField("F877").schema(); + this.f8780 = readerSchema.getField("F878").schema(); + this.f8790 = readerSchema.getField("F879").schema(); + this.f8800 = readerSchema.getField("F880").schema(); + this.f8810 = readerSchema.getField("F881").schema(); + this.f8820 = readerSchema.getField("F882").schema(); + this.f8830 = readerSchema.getField("F883").schema(); + this.f8840 = readerSchema.getField("F884").schema(); + this.f8850 = readerSchema.getField("F885").schema(); + this.f8860 = readerSchema.getField("F886").schema(); + this.f8870 = readerSchema.getField("F887").schema(); + this.f8880 = readerSchema.getField("F888").schema(); + this.f8890 = readerSchema.getField("F889").schema(); + this.f8900 = readerSchema.getField("F890").schema(); + this.f8910 = readerSchema.getField("F891").schema(); + this.f8920 = readerSchema.getField("F892").schema(); + this.f8930 = readerSchema.getField("F893").schema(); + this.f8940 = readerSchema.getField("F894").schema(); + this.f8950 = readerSchema.getField("F895").schema(); + this.f8960 = readerSchema.getField("F896").schema(); + this.f8970 = readerSchema.getField("F897").schema(); + this.f8980 = readerSchema.getField("F898").schema(); + this.f8990 = readerSchema.getField("F899").schema(); + this.f9000 = readerSchema.getField("F900").schema(); + this.f9010 = readerSchema.getField("F901").schema(); + this.f9020 = readerSchema.getField("F902").schema(); + this.f9030 = readerSchema.getField("F903").schema(); + this.f9040 = readerSchema.getField("F904").schema(); + this.f9050 = readerSchema.getField("F905").schema(); + this.f9060 = readerSchema.getField("F906").schema(); + this.f9070 = readerSchema.getField("F907").schema(); + this.f9080 = readerSchema.getField("F908").schema(); + this.f9090 = readerSchema.getField("F909").schema(); + this.f9100 = readerSchema.getField("F910").schema(); + this.f9110 = readerSchema.getField("F911").schema(); + this.f9120 = readerSchema.getField("F912").schema(); + this.f9130 = readerSchema.getField("F913").schema(); + this.f9140 = readerSchema.getField("F914").schema(); + this.f9150 = readerSchema.getField("F915").schema(); + this.f9160 = readerSchema.getField("F916").schema(); + this.f9170 = readerSchema.getField("F917").schema(); + this.f9180 = readerSchema.getField("F918").schema(); + this.f9190 = readerSchema.getField("F919").schema(); + this.f9200 = readerSchema.getField("F920").schema(); + this.f9210 = readerSchema.getField("F921").schema(); + this.f9220 = readerSchema.getField("F922").schema(); + this.f9230 = readerSchema.getField("F923").schema(); + this.f9240 = readerSchema.getField("F924").schema(); + this.f9250 = readerSchema.getField("F925").schema(); + this.f9260 = readerSchema.getField("F926").schema(); + this.f9270 = readerSchema.getField("F927").schema(); + this.f9280 = readerSchema.getField("F928").schema(); + this.f9290 = readerSchema.getField("F929").schema(); + this.f9300 = readerSchema.getField("F930").schema(); + this.f9310 = readerSchema.getField("F931").schema(); + this.f9320 = readerSchema.getField("F932").schema(); + this.f9330 = readerSchema.getField("F933").schema(); + this.f9340 = readerSchema.getField("F934").schema(); + this.f9350 = readerSchema.getField("F935").schema(); + this.f9360 = readerSchema.getField("F936").schema(); + this.f9370 = readerSchema.getField("F937").schema(); + this.f9380 = readerSchema.getField("F938").schema(); + this.f9390 = readerSchema.getField("F939").schema(); + this.f9400 = readerSchema.getField("F940").schema(); + this.f9410 = readerSchema.getField("F941").schema(); + this.f9420 = readerSchema.getField("F942").schema(); + this.f9430 = readerSchema.getField("F943").schema(); + this.f9440 = readerSchema.getField("F944").schema(); + this.f9450 = readerSchema.getField("F945").schema(); + this.f9460 = readerSchema.getField("F946").schema(); + this.f9470 = readerSchema.getField("F947").schema(); + this.f9480 = readerSchema.getField("F948").schema(); + this.f9490 = readerSchema.getField("F949").schema(); + this.f9500 = readerSchema.getField("F950").schema(); + this.f9510 = readerSchema.getField("F951").schema(); + this.f9520 = readerSchema.getField("F952").schema(); + this.f9530 = readerSchema.getField("F953").schema(); + this.f9540 = readerSchema.getField("F954").schema(); + this.f9550 = readerSchema.getField("F955").schema(); + this.f9560 = readerSchema.getField("F956").schema(); + this.f9570 = readerSchema.getField("F957").schema(); + this.f9580 = readerSchema.getField("F958").schema(); + this.f9590 = readerSchema.getField("F959").schema(); + this.f9600 = readerSchema.getField("F960").schema(); + this.f9610 = readerSchema.getField("F961").schema(); + this.f9620 = readerSchema.getField("F962").schema(); + this.f9630 = readerSchema.getField("F963").schema(); + this.f9640 = readerSchema.getField("F964").schema(); + this.f9650 = readerSchema.getField("F965").schema(); + this.f9660 = readerSchema.getField("F966").schema(); + this.f9670 = readerSchema.getField("F967").schema(); + this.f9680 = readerSchema.getField("F968").schema(); + this.f9690 = readerSchema.getField("F969").schema(); + this.f9700 = readerSchema.getField("F970").schema(); + this.f9710 = readerSchema.getField("F971").schema(); + this.f9720 = readerSchema.getField("F972").schema(); + this.f9730 = readerSchema.getField("F973").schema(); + this.f9740 = readerSchema.getField("F974").schema(); + this.f9750 = readerSchema.getField("F975").schema(); + this.f9760 = readerSchema.getField("F976").schema(); + this.f9770 = readerSchema.getField("F977").schema(); + this.f9780 = readerSchema.getField("F978").schema(); + this.f9790 = readerSchema.getField("F979").schema(); + this.f9800 = readerSchema.getField("F980").schema(); + this.f9810 = readerSchema.getField("F981").schema(); + this.f9820 = readerSchema.getField("F982").schema(); + this.f9830 = readerSchema.getField("F983").schema(); + this.f9840 = readerSchema.getField("F984").schema(); + this.f9850 = readerSchema.getField("F985").schema(); + this.f9860 = readerSchema.getField("F986").schema(); + this.f9870 = readerSchema.getField("F987").schema(); + this.f9880 = readerSchema.getField("F988").schema(); + this.f9890 = readerSchema.getField("F989").schema(); + this.f9900 = readerSchema.getField("F990").schema(); + this.f9910 = readerSchema.getField("F991").schema(); + this.f9920 = readerSchema.getField("F992").schema(); + this.f9930 = readerSchema.getField("F993").schema(); + this.f9940 = readerSchema.getField("F994").schema(); + this.f9950 = readerSchema.getField("F995").schema(); + this.f9960 = readerSchema.getField("F996").schema(); + this.f9970 = readerSchema.getField("F997").schema(); + this.f9980 = readerSchema.getField("F998").schema(); + this.f9990 = readerSchema.getField("F999").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'F0': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(1, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'F1': "+ unionIndex1)); + } + } + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(2, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence2; + Object oldString2 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(2); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(2, charSequence2); + } else { + throw new RuntimeException(("Illegal union index for 'F2': "+ unionIndex2)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(3, null); + } else { + if (unionIndex3 == 1) { + Utf8 charSequence3; + Object oldString3 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(3); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(3, charSequence3); + } else { + throw new RuntimeException(("Illegal union index for 'F3': "+ unionIndex3)); + } + } + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(4, null); + } else { + if (unionIndex4 == 1) { + Utf8 charSequence4; + Object oldString4 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(4); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(4, charSequence4); + } else { + throw new RuntimeException(("Illegal union index for 'F4': "+ unionIndex4)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(5, null); + } else { + if (unionIndex5 == 1) { + Utf8 charSequence5; + Object oldString5 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(5); + if (oldString5 instanceof Utf8) { + charSequence5 = (decoder).readString(((Utf8) oldString5)); + } else { + charSequence5 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(5, charSequence5); + } else { + throw new RuntimeException(("Illegal union index for 'F5': "+ unionIndex5)); + } + } + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(6, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence6; + Object oldString6 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(6); + if (oldString6 instanceof Utf8) { + charSequence6 = (decoder).readString(((Utf8) oldString6)); + } else { + charSequence6 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(6, charSequence6); + } else { + throw new RuntimeException(("Illegal union index for 'F6': "+ unionIndex6)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(7, null); + } else { + if (unionIndex7 == 1) { + Utf8 charSequence7; + Object oldString7 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(7); + if (oldString7 instanceof Utf8) { + charSequence7 = (decoder).readString(((Utf8) oldString7)); + } else { + charSequence7 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(7, charSequence7); + } else { + throw new RuntimeException(("Illegal union index for 'F7': "+ unionIndex7)); + } + } + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(8, null); + } else { + if (unionIndex8 == 1) { + Utf8 charSequence8; + Object oldString8 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(8); + if (oldString8 instanceof Utf8) { + charSequence8 = (decoder).readString(((Utf8) oldString8)); + } else { + charSequence8 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(8, charSequence8); + } else { + throw new RuntimeException(("Illegal union index for 'F8': "+ unionIndex8)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex9 = (decoder.readIndex()); + if (unionIndex9 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(9, null); + } else { + if (unionIndex9 == 1) { + Utf8 charSequence9; + Object oldString9 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(9); + if (oldString9 instanceof Utf8) { + charSequence9 = (decoder).readString(((Utf8) oldString9)); + } else { + charSequence9 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(9, charSequence9); + } else { + throw new RuntimeException(("Illegal union index for 'F9': "+ unionIndex9)); + } + } + int unionIndex10 = (decoder.readIndex()); + if (unionIndex10 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(10, null); + } else { + if (unionIndex10 == 1) { + Utf8 charSequence10; + Object oldString10 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(10); + if (oldString10 instanceof Utf8) { + charSequence10 = (decoder).readString(((Utf8) oldString10)); + } else { + charSequence10 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(10, charSequence10); + } else { + throw new RuntimeException(("Illegal union index for 'F10': "+ unionIndex10)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex11 = (decoder.readIndex()); + if (unionIndex11 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(11, null); + } else { + if (unionIndex11 == 1) { + Utf8 charSequence11; + Object oldString11 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(11); + if (oldString11 instanceof Utf8) { + charSequence11 = (decoder).readString(((Utf8) oldString11)); + } else { + charSequence11 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(11, charSequence11); + } else { + throw new RuntimeException(("Illegal union index for 'F11': "+ unionIndex11)); + } + } + int unionIndex12 = (decoder.readIndex()); + if (unionIndex12 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(12, null); + } else { + if (unionIndex12 == 1) { + Utf8 charSequence12; + Object oldString12 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(12); + if (oldString12 instanceof Utf8) { + charSequence12 = (decoder).readString(((Utf8) oldString12)); + } else { + charSequence12 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(12, charSequence12); + } else { + throw new RuntimeException(("Illegal union index for 'F12': "+ unionIndex12)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex13 = (decoder.readIndex()); + if (unionIndex13 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(13, null); + } else { + if (unionIndex13 == 1) { + Utf8 charSequence13; + Object oldString13 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(13); + if (oldString13 instanceof Utf8) { + charSequence13 = (decoder).readString(((Utf8) oldString13)); + } else { + charSequence13 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(13, charSequence13); + } else { + throw new RuntimeException(("Illegal union index for 'F13': "+ unionIndex13)); + } + } + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(14, null); + } else { + if (unionIndex14 == 1) { + Utf8 charSequence14; + Object oldString14 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(14); + if (oldString14 instanceof Utf8) { + charSequence14 = (decoder).readString(((Utf8) oldString14)); + } else { + charSequence14 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(14, charSequence14); + } else { + throw new RuntimeException(("Illegal union index for 'F14': "+ unionIndex14)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(15, null); + } else { + if (unionIndex15 == 1) { + Utf8 charSequence15; + Object oldString15 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(15); + if (oldString15 instanceof Utf8) { + charSequence15 = (decoder).readString(((Utf8) oldString15)); + } else { + charSequence15 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(15, charSequence15); + } else { + throw new RuntimeException(("Illegal union index for 'F15': "+ unionIndex15)); + } + } + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(16, null); + } else { + if (unionIndex16 == 1) { + Utf8 charSequence16; + Object oldString16 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(16); + if (oldString16 instanceof Utf8) { + charSequence16 = (decoder).readString(((Utf8) oldString16)); + } else { + charSequence16 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(16, charSequence16); + } else { + throw new RuntimeException(("Illegal union index for 'F16': "+ unionIndex16)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex17 = (decoder.readIndex()); + if (unionIndex17 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(17, null); + } else { + if (unionIndex17 == 1) { + Utf8 charSequence17; + Object oldString17 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(17); + if (oldString17 instanceof Utf8) { + charSequence17 = (decoder).readString(((Utf8) oldString17)); + } else { + charSequence17 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(17, charSequence17); + } else { + throw new RuntimeException(("Illegal union index for 'F17': "+ unionIndex17)); + } + } + int unionIndex18 = (decoder.readIndex()); + if (unionIndex18 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(18, null); + } else { + if (unionIndex18 == 1) { + Utf8 charSequence18; + Object oldString18 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(18); + if (oldString18 instanceof Utf8) { + charSequence18 = (decoder).readString(((Utf8) oldString18)); + } else { + charSequence18 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(18, charSequence18); + } else { + throw new RuntimeException(("Illegal union index for 'F18': "+ unionIndex18)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex19 = (decoder.readIndex()); + if (unionIndex19 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(19, null); + } else { + if (unionIndex19 == 1) { + Utf8 charSequence19; + Object oldString19 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(19); + if (oldString19 instanceof Utf8) { + charSequence19 = (decoder).readString(((Utf8) oldString19)); + } else { + charSequence19 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(19, charSequence19); + } else { + throw new RuntimeException(("Illegal union index for 'F19': "+ unionIndex19)); + } + } + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(20, null); + } else { + if (unionIndex20 == 1) { + Utf8 charSequence20; + Object oldString20 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(20); + if (oldString20 instanceof Utf8) { + charSequence20 = (decoder).readString(((Utf8) oldString20)); + } else { + charSequence20 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(20, charSequence20); + } else { + throw new RuntimeException(("Illegal union index for 'F20': "+ unionIndex20)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(21, null); + } else { + if (unionIndex21 == 1) { + Utf8 charSequence21; + Object oldString21 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(21); + if (oldString21 instanceof Utf8) { + charSequence21 = (decoder).readString(((Utf8) oldString21)); + } else { + charSequence21 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(21, charSequence21); + } else { + throw new RuntimeException(("Illegal union index for 'F21': "+ unionIndex21)); + } + } + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(22, null); + } else { + if (unionIndex22 == 1) { + Utf8 charSequence22; + Object oldString22 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(22); + if (oldString22 instanceof Utf8) { + charSequence22 = (decoder).readString(((Utf8) oldString22)); + } else { + charSequence22 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(22, charSequence22); + } else { + throw new RuntimeException(("Illegal union index for 'F22': "+ unionIndex22)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(23, null); + } else { + if (unionIndex23 == 1) { + Utf8 charSequence23; + Object oldString23 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(23); + if (oldString23 instanceof Utf8) { + charSequence23 = (decoder).readString(((Utf8) oldString23)); + } else { + charSequence23 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(23, charSequence23); + } else { + throw new RuntimeException(("Illegal union index for 'F23': "+ unionIndex23)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(24, null); + } else { + if (unionIndex24 == 1) { + Utf8 charSequence24; + Object oldString24 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(24); + if (oldString24 instanceof Utf8) { + charSequence24 = (decoder).readString(((Utf8) oldString24)); + } else { + charSequence24 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(24, charSequence24); + } else { + throw new RuntimeException(("Illegal union index for 'F24': "+ unionIndex24)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(25, null); + } else { + if (unionIndex25 == 1) { + Utf8 charSequence25; + Object oldString25 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(25); + if (oldString25 instanceof Utf8) { + charSequence25 = (decoder).readString(((Utf8) oldString25)); + } else { + charSequence25 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(25, charSequence25); + } else { + throw new RuntimeException(("Illegal union index for 'F25': "+ unionIndex25)); + } + } + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(26, null); + } else { + if (unionIndex26 == 1) { + Utf8 charSequence26; + Object oldString26 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(26); + if (oldString26 instanceof Utf8) { + charSequence26 = (decoder).readString(((Utf8) oldString26)); + } else { + charSequence26 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(26, charSequence26); + } else { + throw new RuntimeException(("Illegal union index for 'F26': "+ unionIndex26)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex27 = (decoder.readIndex()); + if (unionIndex27 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(27, null); + } else { + if (unionIndex27 == 1) { + Utf8 charSequence27; + Object oldString27 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(27); + if (oldString27 instanceof Utf8) { + charSequence27 = (decoder).readString(((Utf8) oldString27)); + } else { + charSequence27 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(27, charSequence27); + } else { + throw new RuntimeException(("Illegal union index for 'F27': "+ unionIndex27)); + } + } + int unionIndex28 = (decoder.readIndex()); + if (unionIndex28 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(28, null); + } else { + if (unionIndex28 == 1) { + Utf8 charSequence28; + Object oldString28 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(28); + if (oldString28 instanceof Utf8) { + charSequence28 = (decoder).readString(((Utf8) oldString28)); + } else { + charSequence28 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(28, charSequence28); + } else { + throw new RuntimeException(("Illegal union index for 'F28': "+ unionIndex28)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex29 = (decoder.readIndex()); + if (unionIndex29 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(29, null); + } else { + if (unionIndex29 == 1) { + Utf8 charSequence29; + Object oldString29 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(29); + if (oldString29 instanceof Utf8) { + charSequence29 = (decoder).readString(((Utf8) oldString29)); + } else { + charSequence29 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(29, charSequence29); + } else { + throw new RuntimeException(("Illegal union index for 'F29': "+ unionIndex29)); + } + } + int unionIndex30 = (decoder.readIndex()); + if (unionIndex30 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(30, null); + } else { + if (unionIndex30 == 1) { + Utf8 charSequence30; + Object oldString30 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(30); + if (oldString30 instanceof Utf8) { + charSequence30 = (decoder).readString(((Utf8) oldString30)); + } else { + charSequence30 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(30, charSequence30); + } else { + throw new RuntimeException(("Illegal union index for 'F30': "+ unionIndex30)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex31 = (decoder.readIndex()); + if (unionIndex31 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(31, null); + } else { + if (unionIndex31 == 1) { + Utf8 charSequence31; + Object oldString31 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(31); + if (oldString31 instanceof Utf8) { + charSequence31 = (decoder).readString(((Utf8) oldString31)); + } else { + charSequence31 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(31, charSequence31); + } else { + throw new RuntimeException(("Illegal union index for 'F31': "+ unionIndex31)); + } + } + int unionIndex32 = (decoder.readIndex()); + if (unionIndex32 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(32, null); + } else { + if (unionIndex32 == 1) { + Utf8 charSequence32; + Object oldString32 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(32); + if (oldString32 instanceof Utf8) { + charSequence32 = (decoder).readString(((Utf8) oldString32)); + } else { + charSequence32 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(32, charSequence32); + } else { + throw new RuntimeException(("Illegal union index for 'F32': "+ unionIndex32)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex33 = (decoder.readIndex()); + if (unionIndex33 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(33, null); + } else { + if (unionIndex33 == 1) { + Utf8 charSequence33; + Object oldString33 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(33); + if (oldString33 instanceof Utf8) { + charSequence33 = (decoder).readString(((Utf8) oldString33)); + } else { + charSequence33 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(33, charSequence33); + } else { + throw new RuntimeException(("Illegal union index for 'F33': "+ unionIndex33)); + } + } + int unionIndex34 = (decoder.readIndex()); + if (unionIndex34 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(34, null); + } else { + if (unionIndex34 == 1) { + Utf8 charSequence34; + Object oldString34 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(34); + if (oldString34 instanceof Utf8) { + charSequence34 = (decoder).readString(((Utf8) oldString34)); + } else { + charSequence34 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(34, charSequence34); + } else { + throw new RuntimeException(("Illegal union index for 'F34': "+ unionIndex34)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex35 = (decoder.readIndex()); + if (unionIndex35 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(35, null); + } else { + if (unionIndex35 == 1) { + Utf8 charSequence35; + Object oldString35 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(35); + if (oldString35 instanceof Utf8) { + charSequence35 = (decoder).readString(((Utf8) oldString35)); + } else { + charSequence35 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(35, charSequence35); + } else { + throw new RuntimeException(("Illegal union index for 'F35': "+ unionIndex35)); + } + } + int unionIndex36 = (decoder.readIndex()); + if (unionIndex36 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(36, null); + } else { + if (unionIndex36 == 1) { + Utf8 charSequence36; + Object oldString36 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(36); + if (oldString36 instanceof Utf8) { + charSequence36 = (decoder).readString(((Utf8) oldString36)); + } else { + charSequence36 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(36, charSequence36); + } else { + throw new RuntimeException(("Illegal union index for 'F36': "+ unionIndex36)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex37 = (decoder.readIndex()); + if (unionIndex37 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(37, null); + } else { + if (unionIndex37 == 1) { + Utf8 charSequence37; + Object oldString37 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(37); + if (oldString37 instanceof Utf8) { + charSequence37 = (decoder).readString(((Utf8) oldString37)); + } else { + charSequence37 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(37, charSequence37); + } else { + throw new RuntimeException(("Illegal union index for 'F37': "+ unionIndex37)); + } + } + int unionIndex38 = (decoder.readIndex()); + if (unionIndex38 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(38, null); + } else { + if (unionIndex38 == 1) { + Utf8 charSequence38; + Object oldString38 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(38); + if (oldString38 instanceof Utf8) { + charSequence38 = (decoder).readString(((Utf8) oldString38)); + } else { + charSequence38 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(38, charSequence38); + } else { + throw new RuntimeException(("Illegal union index for 'F38': "+ unionIndex38)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex39 = (decoder.readIndex()); + if (unionIndex39 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(39, null); + } else { + if (unionIndex39 == 1) { + Utf8 charSequence39; + Object oldString39 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(39); + if (oldString39 instanceof Utf8) { + charSequence39 = (decoder).readString(((Utf8) oldString39)); + } else { + charSequence39 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(39, charSequence39); + } else { + throw new RuntimeException(("Illegal union index for 'F39': "+ unionIndex39)); + } + } + int unionIndex40 = (decoder.readIndex()); + if (unionIndex40 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(40, null); + } else { + if (unionIndex40 == 1) { + Utf8 charSequence40; + Object oldString40 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(40); + if (oldString40 instanceof Utf8) { + charSequence40 = (decoder).readString(((Utf8) oldString40)); + } else { + charSequence40 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(40, charSequence40); + } else { + throw new RuntimeException(("Illegal union index for 'F40': "+ unionIndex40)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex41 = (decoder.readIndex()); + if (unionIndex41 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(41, null); + } else { + if (unionIndex41 == 1) { + Utf8 charSequence41; + Object oldString41 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(41); + if (oldString41 instanceof Utf8) { + charSequence41 = (decoder).readString(((Utf8) oldString41)); + } else { + charSequence41 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(41, charSequence41); + } else { + throw new RuntimeException(("Illegal union index for 'F41': "+ unionIndex41)); + } + } + int unionIndex42 = (decoder.readIndex()); + if (unionIndex42 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(42, null); + } else { + if (unionIndex42 == 1) { + Utf8 charSequence42; + Object oldString42 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(42); + if (oldString42 instanceof Utf8) { + charSequence42 = (decoder).readString(((Utf8) oldString42)); + } else { + charSequence42 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(42, charSequence42); + } else { + throw new RuntimeException(("Illegal union index for 'F42': "+ unionIndex42)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex43 = (decoder.readIndex()); + if (unionIndex43 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(43, null); + } else { + if (unionIndex43 == 1) { + Utf8 charSequence43; + Object oldString43 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(43); + if (oldString43 instanceof Utf8) { + charSequence43 = (decoder).readString(((Utf8) oldString43)); + } else { + charSequence43 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(43, charSequence43); + } else { + throw new RuntimeException(("Illegal union index for 'F43': "+ unionIndex43)); + } + } + int unionIndex44 = (decoder.readIndex()); + if (unionIndex44 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(44, null); + } else { + if (unionIndex44 == 1) { + Utf8 charSequence44; + Object oldString44 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(44); + if (oldString44 instanceof Utf8) { + charSequence44 = (decoder).readString(((Utf8) oldString44)); + } else { + charSequence44 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(44, charSequence44); + } else { + throw new RuntimeException(("Illegal union index for 'F44': "+ unionIndex44)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex45 = (decoder.readIndex()); + if (unionIndex45 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(45, null); + } else { + if (unionIndex45 == 1) { + Utf8 charSequence45; + Object oldString45 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(45); + if (oldString45 instanceof Utf8) { + charSequence45 = (decoder).readString(((Utf8) oldString45)); + } else { + charSequence45 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(45, charSequence45); + } else { + throw new RuntimeException(("Illegal union index for 'F45': "+ unionIndex45)); + } + } + int unionIndex46 = (decoder.readIndex()); + if (unionIndex46 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(46, null); + } else { + if (unionIndex46 == 1) { + Utf8 charSequence46; + Object oldString46 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(46); + if (oldString46 instanceof Utf8) { + charSequence46 = (decoder).readString(((Utf8) oldString46)); + } else { + charSequence46 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(46, charSequence46); + } else { + throw new RuntimeException(("Illegal union index for 'F46': "+ unionIndex46)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex47 = (decoder.readIndex()); + if (unionIndex47 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(47, null); + } else { + if (unionIndex47 == 1) { + Utf8 charSequence47; + Object oldString47 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(47); + if (oldString47 instanceof Utf8) { + charSequence47 = (decoder).readString(((Utf8) oldString47)); + } else { + charSequence47 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(47, charSequence47); + } else { + throw new RuntimeException(("Illegal union index for 'F47': "+ unionIndex47)); + } + } + int unionIndex48 = (decoder.readIndex()); + if (unionIndex48 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(48, null); + } else { + if (unionIndex48 == 1) { + Utf8 charSequence48; + Object oldString48 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(48); + if (oldString48 instanceof Utf8) { + charSequence48 = (decoder).readString(((Utf8) oldString48)); + } else { + charSequence48 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(48, charSequence48); + } else { + throw new RuntimeException(("Illegal union index for 'F48': "+ unionIndex48)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex49 = (decoder.readIndex()); + if (unionIndex49 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(49, null); + } else { + if (unionIndex49 == 1) { + Utf8 charSequence49; + Object oldString49 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(49); + if (oldString49 instanceof Utf8) { + charSequence49 = (decoder).readString(((Utf8) oldString49)); + } else { + charSequence49 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(49, charSequence49); + } else { + throw new RuntimeException(("Illegal union index for 'F49': "+ unionIndex49)); + } + } + int unionIndex50 = (decoder.readIndex()); + if (unionIndex50 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(50, null); + } else { + if (unionIndex50 == 1) { + Utf8 charSequence50; + Object oldString50 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(50); + if (oldString50 instanceof Utf8) { + charSequence50 = (decoder).readString(((Utf8) oldString50)); + } else { + charSequence50 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(50, charSequence50); + } else { + throw new RuntimeException(("Illegal union index for 'F50': "+ unionIndex50)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex51 = (decoder.readIndex()); + if (unionIndex51 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(51, null); + } else { + if (unionIndex51 == 1) { + Utf8 charSequence51; + Object oldString51 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(51); + if (oldString51 instanceof Utf8) { + charSequence51 = (decoder).readString(((Utf8) oldString51)); + } else { + charSequence51 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(51, charSequence51); + } else { + throw new RuntimeException(("Illegal union index for 'F51': "+ unionIndex51)); + } + } + int unionIndex52 = (decoder.readIndex()); + if (unionIndex52 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(52, null); + } else { + if (unionIndex52 == 1) { + Utf8 charSequence52; + Object oldString52 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(52); + if (oldString52 instanceof Utf8) { + charSequence52 = (decoder).readString(((Utf8) oldString52)); + } else { + charSequence52 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(52, charSequence52); + } else { + throw new RuntimeException(("Illegal union index for 'F52': "+ unionIndex52)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex53 = (decoder.readIndex()); + if (unionIndex53 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(53, null); + } else { + if (unionIndex53 == 1) { + Utf8 charSequence53; + Object oldString53 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(53); + if (oldString53 instanceof Utf8) { + charSequence53 = (decoder).readString(((Utf8) oldString53)); + } else { + charSequence53 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(53, charSequence53); + } else { + throw new RuntimeException(("Illegal union index for 'F53': "+ unionIndex53)); + } + } + int unionIndex54 = (decoder.readIndex()); + if (unionIndex54 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(54, null); + } else { + if (unionIndex54 == 1) { + Utf8 charSequence54; + Object oldString54 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(54); + if (oldString54 instanceof Utf8) { + charSequence54 = (decoder).readString(((Utf8) oldString54)); + } else { + charSequence54 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(54, charSequence54); + } else { + throw new RuntimeException(("Illegal union index for 'F54': "+ unionIndex54)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex55 = (decoder.readIndex()); + if (unionIndex55 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(55, null); + } else { + if (unionIndex55 == 1) { + Utf8 charSequence55; + Object oldString55 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(55); + if (oldString55 instanceof Utf8) { + charSequence55 = (decoder).readString(((Utf8) oldString55)); + } else { + charSequence55 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(55, charSequence55); + } else { + throw new RuntimeException(("Illegal union index for 'F55': "+ unionIndex55)); + } + } + int unionIndex56 = (decoder.readIndex()); + if (unionIndex56 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(56, null); + } else { + if (unionIndex56 == 1) { + Utf8 charSequence56; + Object oldString56 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(56); + if (oldString56 instanceof Utf8) { + charSequence56 = (decoder).readString(((Utf8) oldString56)); + } else { + charSequence56 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(56, charSequence56); + } else { + throw new RuntimeException(("Illegal union index for 'F56': "+ unionIndex56)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex57 = (decoder.readIndex()); + if (unionIndex57 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(57, null); + } else { + if (unionIndex57 == 1) { + Utf8 charSequence57; + Object oldString57 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(57); + if (oldString57 instanceof Utf8) { + charSequence57 = (decoder).readString(((Utf8) oldString57)); + } else { + charSequence57 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(57, charSequence57); + } else { + throw new RuntimeException(("Illegal union index for 'F57': "+ unionIndex57)); + } + } + int unionIndex58 = (decoder.readIndex()); + if (unionIndex58 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(58, null); + } else { + if (unionIndex58 == 1) { + Utf8 charSequence58; + Object oldString58 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(58); + if (oldString58 instanceof Utf8) { + charSequence58 = (decoder).readString(((Utf8) oldString58)); + } else { + charSequence58 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(58, charSequence58); + } else { + throw new RuntimeException(("Illegal union index for 'F58': "+ unionIndex58)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex59 = (decoder.readIndex()); + if (unionIndex59 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(59, null); + } else { + if (unionIndex59 == 1) { + Utf8 charSequence59; + Object oldString59 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(59); + if (oldString59 instanceof Utf8) { + charSequence59 = (decoder).readString(((Utf8) oldString59)); + } else { + charSequence59 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(59, charSequence59); + } else { + throw new RuntimeException(("Illegal union index for 'F59': "+ unionIndex59)); + } + } + int unionIndex60 = (decoder.readIndex()); + if (unionIndex60 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(60, null); + } else { + if (unionIndex60 == 1) { + Utf8 charSequence60; + Object oldString60 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(60); + if (oldString60 instanceof Utf8) { + charSequence60 = (decoder).readString(((Utf8) oldString60)); + } else { + charSequence60 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(60, charSequence60); + } else { + throw new RuntimeException(("Illegal union index for 'F60': "+ unionIndex60)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex61 = (decoder.readIndex()); + if (unionIndex61 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(61, null); + } else { + if (unionIndex61 == 1) { + Utf8 charSequence61; + Object oldString61 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(61); + if (oldString61 instanceof Utf8) { + charSequence61 = (decoder).readString(((Utf8) oldString61)); + } else { + charSequence61 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(61, charSequence61); + } else { + throw new RuntimeException(("Illegal union index for 'F61': "+ unionIndex61)); + } + } + int unionIndex62 = (decoder.readIndex()); + if (unionIndex62 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(62, null); + } else { + if (unionIndex62 == 1) { + Utf8 charSequence62; + Object oldString62 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(62); + if (oldString62 instanceof Utf8) { + charSequence62 = (decoder).readString(((Utf8) oldString62)); + } else { + charSequence62 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(62, charSequence62); + } else { + throw new RuntimeException(("Illegal union index for 'F62': "+ unionIndex62)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex63 = (decoder.readIndex()); + if (unionIndex63 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(63, null); + } else { + if (unionIndex63 == 1) { + Utf8 charSequence63; + Object oldString63 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(63); + if (oldString63 instanceof Utf8) { + charSequence63 = (decoder).readString(((Utf8) oldString63)); + } else { + charSequence63 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(63, charSequence63); + } else { + throw new RuntimeException(("Illegal union index for 'F63': "+ unionIndex63)); + } + } + int unionIndex64 = (decoder.readIndex()); + if (unionIndex64 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(64, null); + } else { + if (unionIndex64 == 1) { + Utf8 charSequence64; + Object oldString64 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(64); + if (oldString64 instanceof Utf8) { + charSequence64 = (decoder).readString(((Utf8) oldString64)); + } else { + charSequence64 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(64, charSequence64); + } else { + throw new RuntimeException(("Illegal union index for 'F64': "+ unionIndex64)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex65 = (decoder.readIndex()); + if (unionIndex65 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(65, null); + } else { + if (unionIndex65 == 1) { + Utf8 charSequence65; + Object oldString65 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(65); + if (oldString65 instanceof Utf8) { + charSequence65 = (decoder).readString(((Utf8) oldString65)); + } else { + charSequence65 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(65, charSequence65); + } else { + throw new RuntimeException(("Illegal union index for 'F65': "+ unionIndex65)); + } + } + int unionIndex66 = (decoder.readIndex()); + if (unionIndex66 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(66, null); + } else { + if (unionIndex66 == 1) { + Utf8 charSequence66; + Object oldString66 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(66); + if (oldString66 instanceof Utf8) { + charSequence66 = (decoder).readString(((Utf8) oldString66)); + } else { + charSequence66 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(66, charSequence66); + } else { + throw new RuntimeException(("Illegal union index for 'F66': "+ unionIndex66)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex67 = (decoder.readIndex()); + if (unionIndex67 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(67, null); + } else { + if (unionIndex67 == 1) { + Utf8 charSequence67; + Object oldString67 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(67); + if (oldString67 instanceof Utf8) { + charSequence67 = (decoder).readString(((Utf8) oldString67)); + } else { + charSequence67 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(67, charSequence67); + } else { + throw new RuntimeException(("Illegal union index for 'F67': "+ unionIndex67)); + } + } + int unionIndex68 = (decoder.readIndex()); + if (unionIndex68 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(68, null); + } else { + if (unionIndex68 == 1) { + Utf8 charSequence68; + Object oldString68 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(68); + if (oldString68 instanceof Utf8) { + charSequence68 = (decoder).readString(((Utf8) oldString68)); + } else { + charSequence68 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(68, charSequence68); + } else { + throw new RuntimeException(("Illegal union index for 'F68': "+ unionIndex68)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex69 = (decoder.readIndex()); + if (unionIndex69 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(69, null); + } else { + if (unionIndex69 == 1) { + Utf8 charSequence69; + Object oldString69 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(69); + if (oldString69 instanceof Utf8) { + charSequence69 = (decoder).readString(((Utf8) oldString69)); + } else { + charSequence69 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(69, charSequence69); + } else { + throw new RuntimeException(("Illegal union index for 'F69': "+ unionIndex69)); + } + } + int unionIndex70 = (decoder.readIndex()); + if (unionIndex70 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(70, null); + } else { + if (unionIndex70 == 1) { + Utf8 charSequence70; + Object oldString70 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(70); + if (oldString70 instanceof Utf8) { + charSequence70 = (decoder).readString(((Utf8) oldString70)); + } else { + charSequence70 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(70, charSequence70); + } else { + throw new RuntimeException(("Illegal union index for 'F70': "+ unionIndex70)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex71 = (decoder.readIndex()); + if (unionIndex71 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(71, null); + } else { + if (unionIndex71 == 1) { + Utf8 charSequence71; + Object oldString71 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(71); + if (oldString71 instanceof Utf8) { + charSequence71 = (decoder).readString(((Utf8) oldString71)); + } else { + charSequence71 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(71, charSequence71); + } else { + throw new RuntimeException(("Illegal union index for 'F71': "+ unionIndex71)); + } + } + int unionIndex72 = (decoder.readIndex()); + if (unionIndex72 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(72, null); + } else { + if (unionIndex72 == 1) { + Utf8 charSequence72; + Object oldString72 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(72); + if (oldString72 instanceof Utf8) { + charSequence72 = (decoder).readString(((Utf8) oldString72)); + } else { + charSequence72 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(72, charSequence72); + } else { + throw new RuntimeException(("Illegal union index for 'F72': "+ unionIndex72)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex73 = (decoder.readIndex()); + if (unionIndex73 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(73, null); + } else { + if (unionIndex73 == 1) { + Utf8 charSequence73; + Object oldString73 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(73); + if (oldString73 instanceof Utf8) { + charSequence73 = (decoder).readString(((Utf8) oldString73)); + } else { + charSequence73 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(73, charSequence73); + } else { + throw new RuntimeException(("Illegal union index for 'F73': "+ unionIndex73)); + } + } + int unionIndex74 = (decoder.readIndex()); + if (unionIndex74 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(74, null); + } else { + if (unionIndex74 == 1) { + Utf8 charSequence74; + Object oldString74 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(74); + if (oldString74 instanceof Utf8) { + charSequence74 = (decoder).readString(((Utf8) oldString74)); + } else { + charSequence74 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(74, charSequence74); + } else { + throw new RuntimeException(("Illegal union index for 'F74': "+ unionIndex74)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex75 = (decoder.readIndex()); + if (unionIndex75 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(75, null); + } else { + if (unionIndex75 == 1) { + Utf8 charSequence75; + Object oldString75 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(75); + if (oldString75 instanceof Utf8) { + charSequence75 = (decoder).readString(((Utf8) oldString75)); + } else { + charSequence75 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(75, charSequence75); + } else { + throw new RuntimeException(("Illegal union index for 'F75': "+ unionIndex75)); + } + } + int unionIndex76 = (decoder.readIndex()); + if (unionIndex76 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(76, null); + } else { + if (unionIndex76 == 1) { + Utf8 charSequence76; + Object oldString76 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(76); + if (oldString76 instanceof Utf8) { + charSequence76 = (decoder).readString(((Utf8) oldString76)); + } else { + charSequence76 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(76, charSequence76); + } else { + throw new RuntimeException(("Illegal union index for 'F76': "+ unionIndex76)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex77 = (decoder.readIndex()); + if (unionIndex77 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(77, null); + } else { + if (unionIndex77 == 1) { + Utf8 charSequence77; + Object oldString77 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(77); + if (oldString77 instanceof Utf8) { + charSequence77 = (decoder).readString(((Utf8) oldString77)); + } else { + charSequence77 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(77, charSequence77); + } else { + throw new RuntimeException(("Illegal union index for 'F77': "+ unionIndex77)); + } + } + int unionIndex78 = (decoder.readIndex()); + if (unionIndex78 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(78, null); + } else { + if (unionIndex78 == 1) { + Utf8 charSequence78; + Object oldString78 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(78); + if (oldString78 instanceof Utf8) { + charSequence78 = (decoder).readString(((Utf8) oldString78)); + } else { + charSequence78 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(78, charSequence78); + } else { + throw new RuntimeException(("Illegal union index for 'F78': "+ unionIndex78)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex79 = (decoder.readIndex()); + if (unionIndex79 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(79, null); + } else { + if (unionIndex79 == 1) { + Utf8 charSequence79; + Object oldString79 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(79); + if (oldString79 instanceof Utf8) { + charSequence79 = (decoder).readString(((Utf8) oldString79)); + } else { + charSequence79 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(79, charSequence79); + } else { + throw new RuntimeException(("Illegal union index for 'F79': "+ unionIndex79)); + } + } + int unionIndex80 = (decoder.readIndex()); + if (unionIndex80 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(80, null); + } else { + if (unionIndex80 == 1) { + Utf8 charSequence80; + Object oldString80 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(80); + if (oldString80 instanceof Utf8) { + charSequence80 = (decoder).readString(((Utf8) oldString80)); + } else { + charSequence80 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(80, charSequence80); + } else { + throw new RuntimeException(("Illegal union index for 'F80': "+ unionIndex80)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex81 = (decoder.readIndex()); + if (unionIndex81 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(81, null); + } else { + if (unionIndex81 == 1) { + Utf8 charSequence81; + Object oldString81 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(81); + if (oldString81 instanceof Utf8) { + charSequence81 = (decoder).readString(((Utf8) oldString81)); + } else { + charSequence81 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(81, charSequence81); + } else { + throw new RuntimeException(("Illegal union index for 'F81': "+ unionIndex81)); + } + } + int unionIndex82 = (decoder.readIndex()); + if (unionIndex82 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(82, null); + } else { + if (unionIndex82 == 1) { + Utf8 charSequence82; + Object oldString82 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(82); + if (oldString82 instanceof Utf8) { + charSequence82 = (decoder).readString(((Utf8) oldString82)); + } else { + charSequence82 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(82, charSequence82); + } else { + throw new RuntimeException(("Illegal union index for 'F82': "+ unionIndex82)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex83 = (decoder.readIndex()); + if (unionIndex83 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(83, null); + } else { + if (unionIndex83 == 1) { + Utf8 charSequence83; + Object oldString83 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(83); + if (oldString83 instanceof Utf8) { + charSequence83 = (decoder).readString(((Utf8) oldString83)); + } else { + charSequence83 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(83, charSequence83); + } else { + throw new RuntimeException(("Illegal union index for 'F83': "+ unionIndex83)); + } + } + int unionIndex84 = (decoder.readIndex()); + if (unionIndex84 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(84, null); + } else { + if (unionIndex84 == 1) { + Utf8 charSequence84; + Object oldString84 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(84); + if (oldString84 instanceof Utf8) { + charSequence84 = (decoder).readString(((Utf8) oldString84)); + } else { + charSequence84 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(84, charSequence84); + } else { + throw new RuntimeException(("Illegal union index for 'F84': "+ unionIndex84)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex85 = (decoder.readIndex()); + if (unionIndex85 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(85, null); + } else { + if (unionIndex85 == 1) { + Utf8 charSequence85; + Object oldString85 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(85); + if (oldString85 instanceof Utf8) { + charSequence85 = (decoder).readString(((Utf8) oldString85)); + } else { + charSequence85 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(85, charSequence85); + } else { + throw new RuntimeException(("Illegal union index for 'F85': "+ unionIndex85)); + } + } + int unionIndex86 = (decoder.readIndex()); + if (unionIndex86 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(86, null); + } else { + if (unionIndex86 == 1) { + Utf8 charSequence86; + Object oldString86 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(86); + if (oldString86 instanceof Utf8) { + charSequence86 = (decoder).readString(((Utf8) oldString86)); + } else { + charSequence86 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(86, charSequence86); + } else { + throw new RuntimeException(("Illegal union index for 'F86': "+ unionIndex86)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex87 = (decoder.readIndex()); + if (unionIndex87 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(87, null); + } else { + if (unionIndex87 == 1) { + Utf8 charSequence87; + Object oldString87 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(87); + if (oldString87 instanceof Utf8) { + charSequence87 = (decoder).readString(((Utf8) oldString87)); + } else { + charSequence87 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(87, charSequence87); + } else { + throw new RuntimeException(("Illegal union index for 'F87': "+ unionIndex87)); + } + } + int unionIndex88 = (decoder.readIndex()); + if (unionIndex88 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(88, null); + } else { + if (unionIndex88 == 1) { + Utf8 charSequence88; + Object oldString88 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(88); + if (oldString88 instanceof Utf8) { + charSequence88 = (decoder).readString(((Utf8) oldString88)); + } else { + charSequence88 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(88, charSequence88); + } else { + throw new RuntimeException(("Illegal union index for 'F88': "+ unionIndex88)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex89 = (decoder.readIndex()); + if (unionIndex89 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(89, null); + } else { + if (unionIndex89 == 1) { + Utf8 charSequence89; + Object oldString89 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(89); + if (oldString89 instanceof Utf8) { + charSequence89 = (decoder).readString(((Utf8) oldString89)); + } else { + charSequence89 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(89, charSequence89); + } else { + throw new RuntimeException(("Illegal union index for 'F89': "+ unionIndex89)); + } + } + int unionIndex90 = (decoder.readIndex()); + if (unionIndex90 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(90, null); + } else { + if (unionIndex90 == 1) { + Utf8 charSequence90; + Object oldString90 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(90); + if (oldString90 instanceof Utf8) { + charSequence90 = (decoder).readString(((Utf8) oldString90)); + } else { + charSequence90 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(90, charSequence90); + } else { + throw new RuntimeException(("Illegal union index for 'F90': "+ unionIndex90)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex91 = (decoder.readIndex()); + if (unionIndex91 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(91, null); + } else { + if (unionIndex91 == 1) { + Utf8 charSequence91; + Object oldString91 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(91); + if (oldString91 instanceof Utf8) { + charSequence91 = (decoder).readString(((Utf8) oldString91)); + } else { + charSequence91 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(91, charSequence91); + } else { + throw new RuntimeException(("Illegal union index for 'F91': "+ unionIndex91)); + } + } + int unionIndex92 = (decoder.readIndex()); + if (unionIndex92 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(92, null); + } else { + if (unionIndex92 == 1) { + Utf8 charSequence92; + Object oldString92 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(92); + if (oldString92 instanceof Utf8) { + charSequence92 = (decoder).readString(((Utf8) oldString92)); + } else { + charSequence92 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(92, charSequence92); + } else { + throw new RuntimeException(("Illegal union index for 'F92': "+ unionIndex92)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex93 = (decoder.readIndex()); + if (unionIndex93 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(93, null); + } else { + if (unionIndex93 == 1) { + Utf8 charSequence93; + Object oldString93 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(93); + if (oldString93 instanceof Utf8) { + charSequence93 = (decoder).readString(((Utf8) oldString93)); + } else { + charSequence93 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(93, charSequence93); + } else { + throw new RuntimeException(("Illegal union index for 'F93': "+ unionIndex93)); + } + } + int unionIndex94 = (decoder.readIndex()); + if (unionIndex94 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(94, null); + } else { + if (unionIndex94 == 1) { + Utf8 charSequence94; + Object oldString94 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(94); + if (oldString94 instanceof Utf8) { + charSequence94 = (decoder).readString(((Utf8) oldString94)); + } else { + charSequence94 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(94, charSequence94); + } else { + throw new RuntimeException(("Illegal union index for 'F94': "+ unionIndex94)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex95 = (decoder.readIndex()); + if (unionIndex95 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(95, null); + } else { + if (unionIndex95 == 1) { + Utf8 charSequence95; + Object oldString95 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(95); + if (oldString95 instanceof Utf8) { + charSequence95 = (decoder).readString(((Utf8) oldString95)); + } else { + charSequence95 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(95, charSequence95); + } else { + throw new RuntimeException(("Illegal union index for 'F95': "+ unionIndex95)); + } + } + int unionIndex96 = (decoder.readIndex()); + if (unionIndex96 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(96, null); + } else { + if (unionIndex96 == 1) { + Utf8 charSequence96; + Object oldString96 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(96); + if (oldString96 instanceof Utf8) { + charSequence96 = (decoder).readString(((Utf8) oldString96)); + } else { + charSequence96 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(96, charSequence96); + } else { + throw new RuntimeException(("Illegal union index for 'F96': "+ unionIndex96)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex97 = (decoder.readIndex()); + if (unionIndex97 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(97, null); + } else { + if (unionIndex97 == 1) { + Utf8 charSequence97; + Object oldString97 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(97); + if (oldString97 instanceof Utf8) { + charSequence97 = (decoder).readString(((Utf8) oldString97)); + } else { + charSequence97 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(97, charSequence97); + } else { + throw new RuntimeException(("Illegal union index for 'F97': "+ unionIndex97)); + } + } + int unionIndex98 = (decoder.readIndex()); + if (unionIndex98 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(98, null); + } else { + if (unionIndex98 == 1) { + Utf8 charSequence98; + Object oldString98 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(98); + if (oldString98 instanceof Utf8) { + charSequence98 = (decoder).readString(((Utf8) oldString98)); + } else { + charSequence98 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(98, charSequence98); + } else { + throw new RuntimeException(("Illegal union index for 'F98': "+ unionIndex98)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex99 = (decoder.readIndex()); + if (unionIndex99 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(99, null); + } else { + if (unionIndex99 == 1) { + Utf8 charSequence99; + Object oldString99 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(99); + if (oldString99 instanceof Utf8) { + charSequence99 = (decoder).readString(((Utf8) oldString99)); + } else { + charSequence99 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(99, charSequence99); + } else { + throw new RuntimeException(("Illegal union index for 'F99': "+ unionIndex99)); + } + } + int unionIndex100 = (decoder.readIndex()); + if (unionIndex100 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(100, null); + } else { + if (unionIndex100 == 1) { + Utf8 charSequence100; + Object oldString100 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(100); + if (oldString100 instanceof Utf8) { + charSequence100 = (decoder).readString(((Utf8) oldString100)); + } else { + charSequence100 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(100, charSequence100); + } else { + throw new RuntimeException(("Illegal union index for 'F100': "+ unionIndex100)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex101 = (decoder.readIndex()); + if (unionIndex101 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(101, null); + } else { + if (unionIndex101 == 1) { + Utf8 charSequence101; + Object oldString101 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(101); + if (oldString101 instanceof Utf8) { + charSequence101 = (decoder).readString(((Utf8) oldString101)); + } else { + charSequence101 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(101, charSequence101); + } else { + throw new RuntimeException(("Illegal union index for 'F101': "+ unionIndex101)); + } + } + int unionIndex102 = (decoder.readIndex()); + if (unionIndex102 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(102, null); + } else { + if (unionIndex102 == 1) { + Utf8 charSequence102; + Object oldString102 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(102); + if (oldString102 instanceof Utf8) { + charSequence102 = (decoder).readString(((Utf8) oldString102)); + } else { + charSequence102 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(102, charSequence102); + } else { + throw new RuntimeException(("Illegal union index for 'F102': "+ unionIndex102)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex103 = (decoder.readIndex()); + if (unionIndex103 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(103, null); + } else { + if (unionIndex103 == 1) { + Utf8 charSequence103; + Object oldString103 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(103); + if (oldString103 instanceof Utf8) { + charSequence103 = (decoder).readString(((Utf8) oldString103)); + } else { + charSequence103 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(103, charSequence103); + } else { + throw new RuntimeException(("Illegal union index for 'F103': "+ unionIndex103)); + } + } + int unionIndex104 = (decoder.readIndex()); + if (unionIndex104 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(104, null); + } else { + if (unionIndex104 == 1) { + Utf8 charSequence104; + Object oldString104 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(104); + if (oldString104 instanceof Utf8) { + charSequence104 = (decoder).readString(((Utf8) oldString104)); + } else { + charSequence104 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(104, charSequence104); + } else { + throw new RuntimeException(("Illegal union index for 'F104': "+ unionIndex104)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex105 = (decoder.readIndex()); + if (unionIndex105 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(105, null); + } else { + if (unionIndex105 == 1) { + Utf8 charSequence105; + Object oldString105 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(105); + if (oldString105 instanceof Utf8) { + charSequence105 = (decoder).readString(((Utf8) oldString105)); + } else { + charSequence105 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(105, charSequence105); + } else { + throw new RuntimeException(("Illegal union index for 'F105': "+ unionIndex105)); + } + } + int unionIndex106 = (decoder.readIndex()); + if (unionIndex106 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(106, null); + } else { + if (unionIndex106 == 1) { + Utf8 charSequence106; + Object oldString106 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(106); + if (oldString106 instanceof Utf8) { + charSequence106 = (decoder).readString(((Utf8) oldString106)); + } else { + charSequence106 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(106, charSequence106); + } else { + throw new RuntimeException(("Illegal union index for 'F106': "+ unionIndex106)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex107 = (decoder.readIndex()); + if (unionIndex107 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(107, null); + } else { + if (unionIndex107 == 1) { + Utf8 charSequence107; + Object oldString107 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(107); + if (oldString107 instanceof Utf8) { + charSequence107 = (decoder).readString(((Utf8) oldString107)); + } else { + charSequence107 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(107, charSequence107); + } else { + throw new RuntimeException(("Illegal union index for 'F107': "+ unionIndex107)); + } + } + int unionIndex108 = (decoder.readIndex()); + if (unionIndex108 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(108, null); + } else { + if (unionIndex108 == 1) { + Utf8 charSequence108; + Object oldString108 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(108); + if (oldString108 instanceof Utf8) { + charSequence108 = (decoder).readString(((Utf8) oldString108)); + } else { + charSequence108 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(108, charSequence108); + } else { + throw new RuntimeException(("Illegal union index for 'F108': "+ unionIndex108)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex109 = (decoder.readIndex()); + if (unionIndex109 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(109, null); + } else { + if (unionIndex109 == 1) { + Utf8 charSequence109; + Object oldString109 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(109); + if (oldString109 instanceof Utf8) { + charSequence109 = (decoder).readString(((Utf8) oldString109)); + } else { + charSequence109 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(109, charSequence109); + } else { + throw new RuntimeException(("Illegal union index for 'F109': "+ unionIndex109)); + } + } + int unionIndex110 = (decoder.readIndex()); + if (unionIndex110 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(110, null); + } else { + if (unionIndex110 == 1) { + Utf8 charSequence110; + Object oldString110 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(110); + if (oldString110 instanceof Utf8) { + charSequence110 = (decoder).readString(((Utf8) oldString110)); + } else { + charSequence110 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(110, charSequence110); + } else { + throw new RuntimeException(("Illegal union index for 'F110': "+ unionIndex110)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex111 = (decoder.readIndex()); + if (unionIndex111 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(111, null); + } else { + if (unionIndex111 == 1) { + Utf8 charSequence111; + Object oldString111 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(111); + if (oldString111 instanceof Utf8) { + charSequence111 = (decoder).readString(((Utf8) oldString111)); + } else { + charSequence111 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(111, charSequence111); + } else { + throw new RuntimeException(("Illegal union index for 'F111': "+ unionIndex111)); + } + } + int unionIndex112 = (decoder.readIndex()); + if (unionIndex112 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(112, null); + } else { + if (unionIndex112 == 1) { + Utf8 charSequence112; + Object oldString112 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(112); + if (oldString112 instanceof Utf8) { + charSequence112 = (decoder).readString(((Utf8) oldString112)); + } else { + charSequence112 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(112, charSequence112); + } else { + throw new RuntimeException(("Illegal union index for 'F112': "+ unionIndex112)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex113 = (decoder.readIndex()); + if (unionIndex113 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(113, null); + } else { + if (unionIndex113 == 1) { + Utf8 charSequence113; + Object oldString113 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(113); + if (oldString113 instanceof Utf8) { + charSequence113 = (decoder).readString(((Utf8) oldString113)); + } else { + charSequence113 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(113, charSequence113); + } else { + throw new RuntimeException(("Illegal union index for 'F113': "+ unionIndex113)); + } + } + int unionIndex114 = (decoder.readIndex()); + if (unionIndex114 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(114, null); + } else { + if (unionIndex114 == 1) { + Utf8 charSequence114; + Object oldString114 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(114); + if (oldString114 instanceof Utf8) { + charSequence114 = (decoder).readString(((Utf8) oldString114)); + } else { + charSequence114 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(114, charSequence114); + } else { + throw new RuntimeException(("Illegal union index for 'F114': "+ unionIndex114)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex115 = (decoder.readIndex()); + if (unionIndex115 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(115, null); + } else { + if (unionIndex115 == 1) { + Utf8 charSequence115; + Object oldString115 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(115); + if (oldString115 instanceof Utf8) { + charSequence115 = (decoder).readString(((Utf8) oldString115)); + } else { + charSequence115 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(115, charSequence115); + } else { + throw new RuntimeException(("Illegal union index for 'F115': "+ unionIndex115)); + } + } + int unionIndex116 = (decoder.readIndex()); + if (unionIndex116 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(116, null); + } else { + if (unionIndex116 == 1) { + Utf8 charSequence116; + Object oldString116 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(116); + if (oldString116 instanceof Utf8) { + charSequence116 = (decoder).readString(((Utf8) oldString116)); + } else { + charSequence116 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(116, charSequence116); + } else { + throw new RuntimeException(("Illegal union index for 'F116': "+ unionIndex116)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex117 = (decoder.readIndex()); + if (unionIndex117 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(117, null); + } else { + if (unionIndex117 == 1) { + Utf8 charSequence117; + Object oldString117 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(117); + if (oldString117 instanceof Utf8) { + charSequence117 = (decoder).readString(((Utf8) oldString117)); + } else { + charSequence117 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(117, charSequence117); + } else { + throw new RuntimeException(("Illegal union index for 'F117': "+ unionIndex117)); + } + } + int unionIndex118 = (decoder.readIndex()); + if (unionIndex118 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(118, null); + } else { + if (unionIndex118 == 1) { + Utf8 charSequence118; + Object oldString118 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(118); + if (oldString118 instanceof Utf8) { + charSequence118 = (decoder).readString(((Utf8) oldString118)); + } else { + charSequence118 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(118, charSequence118); + } else { + throw new RuntimeException(("Illegal union index for 'F118': "+ unionIndex118)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex119 = (decoder.readIndex()); + if (unionIndex119 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(119, null); + } else { + if (unionIndex119 == 1) { + Utf8 charSequence119; + Object oldString119 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(119); + if (oldString119 instanceof Utf8) { + charSequence119 = (decoder).readString(((Utf8) oldString119)); + } else { + charSequence119 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(119, charSequence119); + } else { + throw new RuntimeException(("Illegal union index for 'F119': "+ unionIndex119)); + } + } + int unionIndex120 = (decoder.readIndex()); + if (unionIndex120 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(120, null); + } else { + if (unionIndex120 == 1) { + Utf8 charSequence120; + Object oldString120 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(120); + if (oldString120 instanceof Utf8) { + charSequence120 = (decoder).readString(((Utf8) oldString120)); + } else { + charSequence120 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(120, charSequence120); + } else { + throw new RuntimeException(("Illegal union index for 'F120': "+ unionIndex120)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex121 = (decoder.readIndex()); + if (unionIndex121 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(121, null); + } else { + if (unionIndex121 == 1) { + Utf8 charSequence121; + Object oldString121 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(121); + if (oldString121 instanceof Utf8) { + charSequence121 = (decoder).readString(((Utf8) oldString121)); + } else { + charSequence121 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(121, charSequence121); + } else { + throw new RuntimeException(("Illegal union index for 'F121': "+ unionIndex121)); + } + } + int unionIndex122 = (decoder.readIndex()); + if (unionIndex122 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(122, null); + } else { + if (unionIndex122 == 1) { + Utf8 charSequence122; + Object oldString122 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(122); + if (oldString122 instanceof Utf8) { + charSequence122 = (decoder).readString(((Utf8) oldString122)); + } else { + charSequence122 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(122, charSequence122); + } else { + throw new RuntimeException(("Illegal union index for 'F122': "+ unionIndex122)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex123 = (decoder.readIndex()); + if (unionIndex123 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(123, null); + } else { + if (unionIndex123 == 1) { + Utf8 charSequence123; + Object oldString123 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(123); + if (oldString123 instanceof Utf8) { + charSequence123 = (decoder).readString(((Utf8) oldString123)); + } else { + charSequence123 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(123, charSequence123); + } else { + throw new RuntimeException(("Illegal union index for 'F123': "+ unionIndex123)); + } + } + int unionIndex124 = (decoder.readIndex()); + if (unionIndex124 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(124, null); + } else { + if (unionIndex124 == 1) { + Utf8 charSequence124; + Object oldString124 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(124); + if (oldString124 instanceof Utf8) { + charSequence124 = (decoder).readString(((Utf8) oldString124)); + } else { + charSequence124 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(124, charSequence124); + } else { + throw new RuntimeException(("Illegal union index for 'F124': "+ unionIndex124)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex125 = (decoder.readIndex()); + if (unionIndex125 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(125, null); + } else { + if (unionIndex125 == 1) { + Utf8 charSequence125; + Object oldString125 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(125); + if (oldString125 instanceof Utf8) { + charSequence125 = (decoder).readString(((Utf8) oldString125)); + } else { + charSequence125 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(125, charSequence125); + } else { + throw new RuntimeException(("Illegal union index for 'F125': "+ unionIndex125)); + } + } + int unionIndex126 = (decoder.readIndex()); + if (unionIndex126 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(126, null); + } else { + if (unionIndex126 == 1) { + Utf8 charSequence126; + Object oldString126 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(126); + if (oldString126 instanceof Utf8) { + charSequence126 = (decoder).readString(((Utf8) oldString126)); + } else { + charSequence126 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(126, charSequence126); + } else { + throw new RuntimeException(("Illegal union index for 'F126': "+ unionIndex126)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex127 = (decoder.readIndex()); + if (unionIndex127 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(127, null); + } else { + if (unionIndex127 == 1) { + Utf8 charSequence127; + Object oldString127 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(127); + if (oldString127 instanceof Utf8) { + charSequence127 = (decoder).readString(((Utf8) oldString127)); + } else { + charSequence127 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(127, charSequence127); + } else { + throw new RuntimeException(("Illegal union index for 'F127': "+ unionIndex127)); + } + } + int unionIndex128 = (decoder.readIndex()); + if (unionIndex128 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(128, null); + } else { + if (unionIndex128 == 1) { + Utf8 charSequence128; + Object oldString128 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(128); + if (oldString128 instanceof Utf8) { + charSequence128 = (decoder).readString(((Utf8) oldString128)); + } else { + charSequence128 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(128, charSequence128); + } else { + throw new RuntimeException(("Illegal union index for 'F128': "+ unionIndex128)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex129 = (decoder.readIndex()); + if (unionIndex129 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(129, null); + } else { + if (unionIndex129 == 1) { + Utf8 charSequence129; + Object oldString129 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(129); + if (oldString129 instanceof Utf8) { + charSequence129 = (decoder).readString(((Utf8) oldString129)); + } else { + charSequence129 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(129, charSequence129); + } else { + throw new RuntimeException(("Illegal union index for 'F129': "+ unionIndex129)); + } + } + int unionIndex130 = (decoder.readIndex()); + if (unionIndex130 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(130, null); + } else { + if (unionIndex130 == 1) { + Utf8 charSequence130; + Object oldString130 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(130); + if (oldString130 instanceof Utf8) { + charSequence130 = (decoder).readString(((Utf8) oldString130)); + } else { + charSequence130 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(130, charSequence130); + } else { + throw new RuntimeException(("Illegal union index for 'F130': "+ unionIndex130)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex131 = (decoder.readIndex()); + if (unionIndex131 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(131, null); + } else { + if (unionIndex131 == 1) { + Utf8 charSequence131; + Object oldString131 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(131); + if (oldString131 instanceof Utf8) { + charSequence131 = (decoder).readString(((Utf8) oldString131)); + } else { + charSequence131 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(131, charSequence131); + } else { + throw new RuntimeException(("Illegal union index for 'F131': "+ unionIndex131)); + } + } + int unionIndex132 = (decoder.readIndex()); + if (unionIndex132 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(132, null); + } else { + if (unionIndex132 == 1) { + Utf8 charSequence132; + Object oldString132 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(132); + if (oldString132 instanceof Utf8) { + charSequence132 = (decoder).readString(((Utf8) oldString132)); + } else { + charSequence132 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(132, charSequence132); + } else { + throw new RuntimeException(("Illegal union index for 'F132': "+ unionIndex132)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex133 = (decoder.readIndex()); + if (unionIndex133 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(133, null); + } else { + if (unionIndex133 == 1) { + Utf8 charSequence133; + Object oldString133 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(133); + if (oldString133 instanceof Utf8) { + charSequence133 = (decoder).readString(((Utf8) oldString133)); + } else { + charSequence133 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(133, charSequence133); + } else { + throw new RuntimeException(("Illegal union index for 'F133': "+ unionIndex133)); + } + } + int unionIndex134 = (decoder.readIndex()); + if (unionIndex134 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(134, null); + } else { + if (unionIndex134 == 1) { + Utf8 charSequence134; + Object oldString134 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(134); + if (oldString134 instanceof Utf8) { + charSequence134 = (decoder).readString(((Utf8) oldString134)); + } else { + charSequence134 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(134, charSequence134); + } else { + throw new RuntimeException(("Illegal union index for 'F134': "+ unionIndex134)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex135 = (decoder.readIndex()); + if (unionIndex135 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(135, null); + } else { + if (unionIndex135 == 1) { + Utf8 charSequence135; + Object oldString135 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(135); + if (oldString135 instanceof Utf8) { + charSequence135 = (decoder).readString(((Utf8) oldString135)); + } else { + charSequence135 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(135, charSequence135); + } else { + throw new RuntimeException(("Illegal union index for 'F135': "+ unionIndex135)); + } + } + int unionIndex136 = (decoder.readIndex()); + if (unionIndex136 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(136, null); + } else { + if (unionIndex136 == 1) { + Utf8 charSequence136; + Object oldString136 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(136); + if (oldString136 instanceof Utf8) { + charSequence136 = (decoder).readString(((Utf8) oldString136)); + } else { + charSequence136 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(136, charSequence136); + } else { + throw new RuntimeException(("Illegal union index for 'F136': "+ unionIndex136)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex137 = (decoder.readIndex()); + if (unionIndex137 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(137, null); + } else { + if (unionIndex137 == 1) { + Utf8 charSequence137; + Object oldString137 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(137); + if (oldString137 instanceof Utf8) { + charSequence137 = (decoder).readString(((Utf8) oldString137)); + } else { + charSequence137 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(137, charSequence137); + } else { + throw new RuntimeException(("Illegal union index for 'F137': "+ unionIndex137)); + } + } + int unionIndex138 = (decoder.readIndex()); + if (unionIndex138 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(138, null); + } else { + if (unionIndex138 == 1) { + Utf8 charSequence138; + Object oldString138 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(138); + if (oldString138 instanceof Utf8) { + charSequence138 = (decoder).readString(((Utf8) oldString138)); + } else { + charSequence138 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(138, charSequence138); + } else { + throw new RuntimeException(("Illegal union index for 'F138': "+ unionIndex138)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex139 = (decoder.readIndex()); + if (unionIndex139 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(139, null); + } else { + if (unionIndex139 == 1) { + Utf8 charSequence139; + Object oldString139 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(139); + if (oldString139 instanceof Utf8) { + charSequence139 = (decoder).readString(((Utf8) oldString139)); + } else { + charSequence139 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(139, charSequence139); + } else { + throw new RuntimeException(("Illegal union index for 'F139': "+ unionIndex139)); + } + } + int unionIndex140 = (decoder.readIndex()); + if (unionIndex140 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(140, null); + } else { + if (unionIndex140 == 1) { + Utf8 charSequence140; + Object oldString140 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(140); + if (oldString140 instanceof Utf8) { + charSequence140 = (decoder).readString(((Utf8) oldString140)); + } else { + charSequence140 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(140, charSequence140); + } else { + throw new RuntimeException(("Illegal union index for 'F140': "+ unionIndex140)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex141 = (decoder.readIndex()); + if (unionIndex141 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(141, null); + } else { + if (unionIndex141 == 1) { + Utf8 charSequence141; + Object oldString141 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(141); + if (oldString141 instanceof Utf8) { + charSequence141 = (decoder).readString(((Utf8) oldString141)); + } else { + charSequence141 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(141, charSequence141); + } else { + throw new RuntimeException(("Illegal union index for 'F141': "+ unionIndex141)); + } + } + int unionIndex142 = (decoder.readIndex()); + if (unionIndex142 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(142, null); + } else { + if (unionIndex142 == 1) { + Utf8 charSequence142; + Object oldString142 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(142); + if (oldString142 instanceof Utf8) { + charSequence142 = (decoder).readString(((Utf8) oldString142)); + } else { + charSequence142 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(142, charSequence142); + } else { + throw new RuntimeException(("Illegal union index for 'F142': "+ unionIndex142)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex143 = (decoder.readIndex()); + if (unionIndex143 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(143, null); + } else { + if (unionIndex143 == 1) { + Utf8 charSequence143; + Object oldString143 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(143); + if (oldString143 instanceof Utf8) { + charSequence143 = (decoder).readString(((Utf8) oldString143)); + } else { + charSequence143 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(143, charSequence143); + } else { + throw new RuntimeException(("Illegal union index for 'F143': "+ unionIndex143)); + } + } + int unionIndex144 = (decoder.readIndex()); + if (unionIndex144 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(144, null); + } else { + if (unionIndex144 == 1) { + Utf8 charSequence144; + Object oldString144 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(144); + if (oldString144 instanceof Utf8) { + charSequence144 = (decoder).readString(((Utf8) oldString144)); + } else { + charSequence144 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(144, charSequence144); + } else { + throw new RuntimeException(("Illegal union index for 'F144': "+ unionIndex144)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex145 = (decoder.readIndex()); + if (unionIndex145 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(145, null); + } else { + if (unionIndex145 == 1) { + Utf8 charSequence145; + Object oldString145 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(145); + if (oldString145 instanceof Utf8) { + charSequence145 = (decoder).readString(((Utf8) oldString145)); + } else { + charSequence145 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(145, charSequence145); + } else { + throw new RuntimeException(("Illegal union index for 'F145': "+ unionIndex145)); + } + } + int unionIndex146 = (decoder.readIndex()); + if (unionIndex146 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(146, null); + } else { + if (unionIndex146 == 1) { + Utf8 charSequence146; + Object oldString146 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(146); + if (oldString146 instanceof Utf8) { + charSequence146 = (decoder).readString(((Utf8) oldString146)); + } else { + charSequence146 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(146, charSequence146); + } else { + throw new RuntimeException(("Illegal union index for 'F146': "+ unionIndex146)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex147 = (decoder.readIndex()); + if (unionIndex147 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(147, null); + } else { + if (unionIndex147 == 1) { + Utf8 charSequence147; + Object oldString147 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(147); + if (oldString147 instanceof Utf8) { + charSequence147 = (decoder).readString(((Utf8) oldString147)); + } else { + charSequence147 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(147, charSequence147); + } else { + throw new RuntimeException(("Illegal union index for 'F147': "+ unionIndex147)); + } + } + int unionIndex148 = (decoder.readIndex()); + if (unionIndex148 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(148, null); + } else { + if (unionIndex148 == 1) { + Utf8 charSequence148; + Object oldString148 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(148); + if (oldString148 instanceof Utf8) { + charSequence148 = (decoder).readString(((Utf8) oldString148)); + } else { + charSequence148 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(148, charSequence148); + } else { + throw new RuntimeException(("Illegal union index for 'F148': "+ unionIndex148)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex149 = (decoder.readIndex()); + if (unionIndex149 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(149, null); + } else { + if (unionIndex149 == 1) { + Utf8 charSequence149; + Object oldString149 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(149); + if (oldString149 instanceof Utf8) { + charSequence149 = (decoder).readString(((Utf8) oldString149)); + } else { + charSequence149 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(149, charSequence149); + } else { + throw new RuntimeException(("Illegal union index for 'F149': "+ unionIndex149)); + } + } + int unionIndex150 = (decoder.readIndex()); + if (unionIndex150 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(150, null); + } else { + if (unionIndex150 == 1) { + Utf8 charSequence150; + Object oldString150 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(150); + if (oldString150 instanceof Utf8) { + charSequence150 = (decoder).readString(((Utf8) oldString150)); + } else { + charSequence150 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(150, charSequence150); + } else { + throw new RuntimeException(("Illegal union index for 'F150': "+ unionIndex150)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex151 = (decoder.readIndex()); + if (unionIndex151 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(151, null); + } else { + if (unionIndex151 == 1) { + Utf8 charSequence151; + Object oldString151 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(151); + if (oldString151 instanceof Utf8) { + charSequence151 = (decoder).readString(((Utf8) oldString151)); + } else { + charSequence151 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(151, charSequence151); + } else { + throw new RuntimeException(("Illegal union index for 'F151': "+ unionIndex151)); + } + } + int unionIndex152 = (decoder.readIndex()); + if (unionIndex152 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(152, null); + } else { + if (unionIndex152 == 1) { + Utf8 charSequence152; + Object oldString152 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(152); + if (oldString152 instanceof Utf8) { + charSequence152 = (decoder).readString(((Utf8) oldString152)); + } else { + charSequence152 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(152, charSequence152); + } else { + throw new RuntimeException(("Illegal union index for 'F152': "+ unionIndex152)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex153 = (decoder.readIndex()); + if (unionIndex153 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(153, null); + } else { + if (unionIndex153 == 1) { + Utf8 charSequence153; + Object oldString153 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(153); + if (oldString153 instanceof Utf8) { + charSequence153 = (decoder).readString(((Utf8) oldString153)); + } else { + charSequence153 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(153, charSequence153); + } else { + throw new RuntimeException(("Illegal union index for 'F153': "+ unionIndex153)); + } + } + int unionIndex154 = (decoder.readIndex()); + if (unionIndex154 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(154, null); + } else { + if (unionIndex154 == 1) { + Utf8 charSequence154; + Object oldString154 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(154); + if (oldString154 instanceof Utf8) { + charSequence154 = (decoder).readString(((Utf8) oldString154)); + } else { + charSequence154 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(154, charSequence154); + } else { + throw new RuntimeException(("Illegal union index for 'F154': "+ unionIndex154)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex155 = (decoder.readIndex()); + if (unionIndex155 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(155, null); + } else { + if (unionIndex155 == 1) { + Utf8 charSequence155; + Object oldString155 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(155); + if (oldString155 instanceof Utf8) { + charSequence155 = (decoder).readString(((Utf8) oldString155)); + } else { + charSequence155 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(155, charSequence155); + } else { + throw new RuntimeException(("Illegal union index for 'F155': "+ unionIndex155)); + } + } + int unionIndex156 = (decoder.readIndex()); + if (unionIndex156 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(156, null); + } else { + if (unionIndex156 == 1) { + Utf8 charSequence156; + Object oldString156 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(156); + if (oldString156 instanceof Utf8) { + charSequence156 = (decoder).readString(((Utf8) oldString156)); + } else { + charSequence156 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(156, charSequence156); + } else { + throw new RuntimeException(("Illegal union index for 'F156': "+ unionIndex156)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex157 = (decoder.readIndex()); + if (unionIndex157 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(157, null); + } else { + if (unionIndex157 == 1) { + Utf8 charSequence157; + Object oldString157 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(157); + if (oldString157 instanceof Utf8) { + charSequence157 = (decoder).readString(((Utf8) oldString157)); + } else { + charSequence157 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(157, charSequence157); + } else { + throw new RuntimeException(("Illegal union index for 'F157': "+ unionIndex157)); + } + } + int unionIndex158 = (decoder.readIndex()); + if (unionIndex158 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(158, null); + } else { + if (unionIndex158 == 1) { + Utf8 charSequence158; + Object oldString158 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(158); + if (oldString158 instanceof Utf8) { + charSequence158 = (decoder).readString(((Utf8) oldString158)); + } else { + charSequence158 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(158, charSequence158); + } else { + throw new RuntimeException(("Illegal union index for 'F158': "+ unionIndex158)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex159 = (decoder.readIndex()); + if (unionIndex159 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(159, null); + } else { + if (unionIndex159 == 1) { + Utf8 charSequence159; + Object oldString159 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(159); + if (oldString159 instanceof Utf8) { + charSequence159 = (decoder).readString(((Utf8) oldString159)); + } else { + charSequence159 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(159, charSequence159); + } else { + throw new RuntimeException(("Illegal union index for 'F159': "+ unionIndex159)); + } + } + int unionIndex160 = (decoder.readIndex()); + if (unionIndex160 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(160, null); + } else { + if (unionIndex160 == 1) { + Utf8 charSequence160; + Object oldString160 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(160); + if (oldString160 instanceof Utf8) { + charSequence160 = (decoder).readString(((Utf8) oldString160)); + } else { + charSequence160 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(160, charSequence160); + } else { + throw new RuntimeException(("Illegal union index for 'F160': "+ unionIndex160)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex161 = (decoder.readIndex()); + if (unionIndex161 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(161, null); + } else { + if (unionIndex161 == 1) { + Utf8 charSequence161; + Object oldString161 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(161); + if (oldString161 instanceof Utf8) { + charSequence161 = (decoder).readString(((Utf8) oldString161)); + } else { + charSequence161 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(161, charSequence161); + } else { + throw new RuntimeException(("Illegal union index for 'F161': "+ unionIndex161)); + } + } + int unionIndex162 = (decoder.readIndex()); + if (unionIndex162 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(162, null); + } else { + if (unionIndex162 == 1) { + Utf8 charSequence162; + Object oldString162 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(162); + if (oldString162 instanceof Utf8) { + charSequence162 = (decoder).readString(((Utf8) oldString162)); + } else { + charSequence162 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(162, charSequence162); + } else { + throw new RuntimeException(("Illegal union index for 'F162': "+ unionIndex162)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex163 = (decoder.readIndex()); + if (unionIndex163 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(163, null); + } else { + if (unionIndex163 == 1) { + Utf8 charSequence163; + Object oldString163 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(163); + if (oldString163 instanceof Utf8) { + charSequence163 = (decoder).readString(((Utf8) oldString163)); + } else { + charSequence163 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(163, charSequence163); + } else { + throw new RuntimeException(("Illegal union index for 'F163': "+ unionIndex163)); + } + } + int unionIndex164 = (decoder.readIndex()); + if (unionIndex164 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(164, null); + } else { + if (unionIndex164 == 1) { + Utf8 charSequence164; + Object oldString164 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(164); + if (oldString164 instanceof Utf8) { + charSequence164 = (decoder).readString(((Utf8) oldString164)); + } else { + charSequence164 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(164, charSequence164); + } else { + throw new RuntimeException(("Illegal union index for 'F164': "+ unionIndex164)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex165 = (decoder.readIndex()); + if (unionIndex165 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(165, null); + } else { + if (unionIndex165 == 1) { + Utf8 charSequence165; + Object oldString165 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(165); + if (oldString165 instanceof Utf8) { + charSequence165 = (decoder).readString(((Utf8) oldString165)); + } else { + charSequence165 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(165, charSequence165); + } else { + throw new RuntimeException(("Illegal union index for 'F165': "+ unionIndex165)); + } + } + int unionIndex166 = (decoder.readIndex()); + if (unionIndex166 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(166, null); + } else { + if (unionIndex166 == 1) { + Utf8 charSequence166; + Object oldString166 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(166); + if (oldString166 instanceof Utf8) { + charSequence166 = (decoder).readString(((Utf8) oldString166)); + } else { + charSequence166 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(166, charSequence166); + } else { + throw new RuntimeException(("Illegal union index for 'F166': "+ unionIndex166)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex167 = (decoder.readIndex()); + if (unionIndex167 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(167, null); + } else { + if (unionIndex167 == 1) { + Utf8 charSequence167; + Object oldString167 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(167); + if (oldString167 instanceof Utf8) { + charSequence167 = (decoder).readString(((Utf8) oldString167)); + } else { + charSequence167 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(167, charSequence167); + } else { + throw new RuntimeException(("Illegal union index for 'F167': "+ unionIndex167)); + } + } + int unionIndex168 = (decoder.readIndex()); + if (unionIndex168 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(168, null); + } else { + if (unionIndex168 == 1) { + Utf8 charSequence168; + Object oldString168 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(168); + if (oldString168 instanceof Utf8) { + charSequence168 = (decoder).readString(((Utf8) oldString168)); + } else { + charSequence168 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(168, charSequence168); + } else { + throw new RuntimeException(("Illegal union index for 'F168': "+ unionIndex168)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex169 = (decoder.readIndex()); + if (unionIndex169 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(169, null); + } else { + if (unionIndex169 == 1) { + Utf8 charSequence169; + Object oldString169 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(169); + if (oldString169 instanceof Utf8) { + charSequence169 = (decoder).readString(((Utf8) oldString169)); + } else { + charSequence169 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(169, charSequence169); + } else { + throw new RuntimeException(("Illegal union index for 'F169': "+ unionIndex169)); + } + } + int unionIndex170 = (decoder.readIndex()); + if (unionIndex170 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(170, null); + } else { + if (unionIndex170 == 1) { + Utf8 charSequence170; + Object oldString170 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(170); + if (oldString170 instanceof Utf8) { + charSequence170 = (decoder).readString(((Utf8) oldString170)); + } else { + charSequence170 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(170, charSequence170); + } else { + throw new RuntimeException(("Illegal union index for 'F170': "+ unionIndex170)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex171 = (decoder.readIndex()); + if (unionIndex171 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(171, null); + } else { + if (unionIndex171 == 1) { + Utf8 charSequence171; + Object oldString171 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(171); + if (oldString171 instanceof Utf8) { + charSequence171 = (decoder).readString(((Utf8) oldString171)); + } else { + charSequence171 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(171, charSequence171); + } else { + throw new RuntimeException(("Illegal union index for 'F171': "+ unionIndex171)); + } + } + int unionIndex172 = (decoder.readIndex()); + if (unionIndex172 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(172, null); + } else { + if (unionIndex172 == 1) { + Utf8 charSequence172; + Object oldString172 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(172); + if (oldString172 instanceof Utf8) { + charSequence172 = (decoder).readString(((Utf8) oldString172)); + } else { + charSequence172 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(172, charSequence172); + } else { + throw new RuntimeException(("Illegal union index for 'F172': "+ unionIndex172)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex173 = (decoder.readIndex()); + if (unionIndex173 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(173, null); + } else { + if (unionIndex173 == 1) { + Utf8 charSequence173; + Object oldString173 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(173); + if (oldString173 instanceof Utf8) { + charSequence173 = (decoder).readString(((Utf8) oldString173)); + } else { + charSequence173 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(173, charSequence173); + } else { + throw new RuntimeException(("Illegal union index for 'F173': "+ unionIndex173)); + } + } + int unionIndex174 = (decoder.readIndex()); + if (unionIndex174 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(174, null); + } else { + if (unionIndex174 == 1) { + Utf8 charSequence174; + Object oldString174 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(174); + if (oldString174 instanceof Utf8) { + charSequence174 = (decoder).readString(((Utf8) oldString174)); + } else { + charSequence174 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(174, charSequence174); + } else { + throw new RuntimeException(("Illegal union index for 'F174': "+ unionIndex174)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex175 = (decoder.readIndex()); + if (unionIndex175 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(175, null); + } else { + if (unionIndex175 == 1) { + Utf8 charSequence175; + Object oldString175 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(175); + if (oldString175 instanceof Utf8) { + charSequence175 = (decoder).readString(((Utf8) oldString175)); + } else { + charSequence175 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(175, charSequence175); + } else { + throw new RuntimeException(("Illegal union index for 'F175': "+ unionIndex175)); + } + } + int unionIndex176 = (decoder.readIndex()); + if (unionIndex176 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(176, null); + } else { + if (unionIndex176 == 1) { + Utf8 charSequence176; + Object oldString176 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(176); + if (oldString176 instanceof Utf8) { + charSequence176 = (decoder).readString(((Utf8) oldString176)); + } else { + charSequence176 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(176, charSequence176); + } else { + throw new RuntimeException(("Illegal union index for 'F176': "+ unionIndex176)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex177 = (decoder.readIndex()); + if (unionIndex177 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(177, null); + } else { + if (unionIndex177 == 1) { + Utf8 charSequence177; + Object oldString177 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(177); + if (oldString177 instanceof Utf8) { + charSequence177 = (decoder).readString(((Utf8) oldString177)); + } else { + charSequence177 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(177, charSequence177); + } else { + throw new RuntimeException(("Illegal union index for 'F177': "+ unionIndex177)); + } + } + int unionIndex178 = (decoder.readIndex()); + if (unionIndex178 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(178, null); + } else { + if (unionIndex178 == 1) { + Utf8 charSequence178; + Object oldString178 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(178); + if (oldString178 instanceof Utf8) { + charSequence178 = (decoder).readString(((Utf8) oldString178)); + } else { + charSequence178 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(178, charSequence178); + } else { + throw new RuntimeException(("Illegal union index for 'F178': "+ unionIndex178)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex179 = (decoder.readIndex()); + if (unionIndex179 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(179, null); + } else { + if (unionIndex179 == 1) { + Utf8 charSequence179; + Object oldString179 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(179); + if (oldString179 instanceof Utf8) { + charSequence179 = (decoder).readString(((Utf8) oldString179)); + } else { + charSequence179 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(179, charSequence179); + } else { + throw new RuntimeException(("Illegal union index for 'F179': "+ unionIndex179)); + } + } + int unionIndex180 = (decoder.readIndex()); + if (unionIndex180 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(180, null); + } else { + if (unionIndex180 == 1) { + Utf8 charSequence180; + Object oldString180 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(180); + if (oldString180 instanceof Utf8) { + charSequence180 = (decoder).readString(((Utf8) oldString180)); + } else { + charSequence180 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(180, charSequence180); + } else { + throw new RuntimeException(("Illegal union index for 'F180': "+ unionIndex180)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex181 = (decoder.readIndex()); + if (unionIndex181 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(181, null); + } else { + if (unionIndex181 == 1) { + Utf8 charSequence181; + Object oldString181 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(181); + if (oldString181 instanceof Utf8) { + charSequence181 = (decoder).readString(((Utf8) oldString181)); + } else { + charSequence181 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(181, charSequence181); + } else { + throw new RuntimeException(("Illegal union index for 'F181': "+ unionIndex181)); + } + } + int unionIndex182 = (decoder.readIndex()); + if (unionIndex182 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(182, null); + } else { + if (unionIndex182 == 1) { + Utf8 charSequence182; + Object oldString182 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(182); + if (oldString182 instanceof Utf8) { + charSequence182 = (decoder).readString(((Utf8) oldString182)); + } else { + charSequence182 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(182, charSequence182); + } else { + throw new RuntimeException(("Illegal union index for 'F182': "+ unionIndex182)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex183 = (decoder.readIndex()); + if (unionIndex183 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(183, null); + } else { + if (unionIndex183 == 1) { + Utf8 charSequence183; + Object oldString183 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(183); + if (oldString183 instanceof Utf8) { + charSequence183 = (decoder).readString(((Utf8) oldString183)); + } else { + charSequence183 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(183, charSequence183); + } else { + throw new RuntimeException(("Illegal union index for 'F183': "+ unionIndex183)); + } + } + int unionIndex184 = (decoder.readIndex()); + if (unionIndex184 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(184, null); + } else { + if (unionIndex184 == 1) { + Utf8 charSequence184; + Object oldString184 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(184); + if (oldString184 instanceof Utf8) { + charSequence184 = (decoder).readString(((Utf8) oldString184)); + } else { + charSequence184 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(184, charSequence184); + } else { + throw new RuntimeException(("Illegal union index for 'F184': "+ unionIndex184)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex185 = (decoder.readIndex()); + if (unionIndex185 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(185, null); + } else { + if (unionIndex185 == 1) { + Utf8 charSequence185; + Object oldString185 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(185); + if (oldString185 instanceof Utf8) { + charSequence185 = (decoder).readString(((Utf8) oldString185)); + } else { + charSequence185 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(185, charSequence185); + } else { + throw new RuntimeException(("Illegal union index for 'F185': "+ unionIndex185)); + } + } + int unionIndex186 = (decoder.readIndex()); + if (unionIndex186 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(186, null); + } else { + if (unionIndex186 == 1) { + Utf8 charSequence186; + Object oldString186 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(186); + if (oldString186 instanceof Utf8) { + charSequence186 = (decoder).readString(((Utf8) oldString186)); + } else { + charSequence186 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(186, charSequence186); + } else { + throw new RuntimeException(("Illegal union index for 'F186': "+ unionIndex186)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex187 = (decoder.readIndex()); + if (unionIndex187 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(187, null); + } else { + if (unionIndex187 == 1) { + Utf8 charSequence187; + Object oldString187 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(187); + if (oldString187 instanceof Utf8) { + charSequence187 = (decoder).readString(((Utf8) oldString187)); + } else { + charSequence187 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(187, charSequence187); + } else { + throw new RuntimeException(("Illegal union index for 'F187': "+ unionIndex187)); + } + } + int unionIndex188 = (decoder.readIndex()); + if (unionIndex188 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(188, null); + } else { + if (unionIndex188 == 1) { + Utf8 charSequence188; + Object oldString188 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(188); + if (oldString188 instanceof Utf8) { + charSequence188 = (decoder).readString(((Utf8) oldString188)); + } else { + charSequence188 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(188, charSequence188); + } else { + throw new RuntimeException(("Illegal union index for 'F188': "+ unionIndex188)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex189 = (decoder.readIndex()); + if (unionIndex189 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(189, null); + } else { + if (unionIndex189 == 1) { + Utf8 charSequence189; + Object oldString189 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(189); + if (oldString189 instanceof Utf8) { + charSequence189 = (decoder).readString(((Utf8) oldString189)); + } else { + charSequence189 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(189, charSequence189); + } else { + throw new RuntimeException(("Illegal union index for 'F189': "+ unionIndex189)); + } + } + int unionIndex190 = (decoder.readIndex()); + if (unionIndex190 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(190, null); + } else { + if (unionIndex190 == 1) { + Utf8 charSequence190; + Object oldString190 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(190); + if (oldString190 instanceof Utf8) { + charSequence190 = (decoder).readString(((Utf8) oldString190)); + } else { + charSequence190 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(190, charSequence190); + } else { + throw new RuntimeException(("Illegal union index for 'F190': "+ unionIndex190)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex191 = (decoder.readIndex()); + if (unionIndex191 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(191, null); + } else { + if (unionIndex191 == 1) { + Utf8 charSequence191; + Object oldString191 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(191); + if (oldString191 instanceof Utf8) { + charSequence191 = (decoder).readString(((Utf8) oldString191)); + } else { + charSequence191 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(191, charSequence191); + } else { + throw new RuntimeException(("Illegal union index for 'F191': "+ unionIndex191)); + } + } + int unionIndex192 = (decoder.readIndex()); + if (unionIndex192 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(192, null); + } else { + if (unionIndex192 == 1) { + Utf8 charSequence192; + Object oldString192 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(192); + if (oldString192 instanceof Utf8) { + charSequence192 = (decoder).readString(((Utf8) oldString192)); + } else { + charSequence192 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(192, charSequence192); + } else { + throw new RuntimeException(("Illegal union index for 'F192': "+ unionIndex192)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex193 = (decoder.readIndex()); + if (unionIndex193 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(193, null); + } else { + if (unionIndex193 == 1) { + Utf8 charSequence193; + Object oldString193 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(193); + if (oldString193 instanceof Utf8) { + charSequence193 = (decoder).readString(((Utf8) oldString193)); + } else { + charSequence193 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(193, charSequence193); + } else { + throw new RuntimeException(("Illegal union index for 'F193': "+ unionIndex193)); + } + } + int unionIndex194 = (decoder.readIndex()); + if (unionIndex194 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(194, null); + } else { + if (unionIndex194 == 1) { + Utf8 charSequence194; + Object oldString194 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(194); + if (oldString194 instanceof Utf8) { + charSequence194 = (decoder).readString(((Utf8) oldString194)); + } else { + charSequence194 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(194, charSequence194); + } else { + throw new RuntimeException(("Illegal union index for 'F194': "+ unionIndex194)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex195 = (decoder.readIndex()); + if (unionIndex195 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(195, null); + } else { + if (unionIndex195 == 1) { + Utf8 charSequence195; + Object oldString195 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(195); + if (oldString195 instanceof Utf8) { + charSequence195 = (decoder).readString(((Utf8) oldString195)); + } else { + charSequence195 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(195, charSequence195); + } else { + throw new RuntimeException(("Illegal union index for 'F195': "+ unionIndex195)); + } + } + int unionIndex196 = (decoder.readIndex()); + if (unionIndex196 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(196, null); + } else { + if (unionIndex196 == 1) { + Utf8 charSequence196; + Object oldString196 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(196); + if (oldString196 instanceof Utf8) { + charSequence196 = (decoder).readString(((Utf8) oldString196)); + } else { + charSequence196 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(196, charSequence196); + } else { + throw new RuntimeException(("Illegal union index for 'F196': "+ unionIndex196)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex197 = (decoder.readIndex()); + if (unionIndex197 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(197, null); + } else { + if (unionIndex197 == 1) { + Utf8 charSequence197; + Object oldString197 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(197); + if (oldString197 instanceof Utf8) { + charSequence197 = (decoder).readString(((Utf8) oldString197)); + } else { + charSequence197 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(197, charSequence197); + } else { + throw new RuntimeException(("Illegal union index for 'F197': "+ unionIndex197)); + } + } + int unionIndex198 = (decoder.readIndex()); + if (unionIndex198 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(198, null); + } else { + if (unionIndex198 == 1) { + Utf8 charSequence198; + Object oldString198 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(198); + if (oldString198 instanceof Utf8) { + charSequence198 = (decoder).readString(((Utf8) oldString198)); + } else { + charSequence198 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(198, charSequence198); + } else { + throw new RuntimeException(("Illegal union index for 'F198': "+ unionIndex198)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex199 = (decoder.readIndex()); + if (unionIndex199 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(199, null); + } else { + if (unionIndex199 == 1) { + Utf8 charSequence199; + Object oldString199 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(199); + if (oldString199 instanceof Utf8) { + charSequence199 = (decoder).readString(((Utf8) oldString199)); + } else { + charSequence199 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(199, charSequence199); + } else { + throw new RuntimeException(("Illegal union index for 'F199': "+ unionIndex199)); + } + } + int unionIndex200 = (decoder.readIndex()); + if (unionIndex200 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(200, null); + } else { + if (unionIndex200 == 1) { + Utf8 charSequence200; + Object oldString200 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(200); + if (oldString200 instanceof Utf8) { + charSequence200 = (decoder).readString(((Utf8) oldString200)); + } else { + charSequence200 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(200, charSequence200); + } else { + throw new RuntimeException(("Illegal union index for 'F200': "+ unionIndex200)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex201 = (decoder.readIndex()); + if (unionIndex201 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(201, null); + } else { + if (unionIndex201 == 1) { + Utf8 charSequence201; + Object oldString201 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(201); + if (oldString201 instanceof Utf8) { + charSequence201 = (decoder).readString(((Utf8) oldString201)); + } else { + charSequence201 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(201, charSequence201); + } else { + throw new RuntimeException(("Illegal union index for 'F201': "+ unionIndex201)); + } + } + int unionIndex202 = (decoder.readIndex()); + if (unionIndex202 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(202, null); + } else { + if (unionIndex202 == 1) { + Utf8 charSequence202; + Object oldString202 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(202); + if (oldString202 instanceof Utf8) { + charSequence202 = (decoder).readString(((Utf8) oldString202)); + } else { + charSequence202 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(202, charSequence202); + } else { + throw new RuntimeException(("Illegal union index for 'F202': "+ unionIndex202)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex203 = (decoder.readIndex()); + if (unionIndex203 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(203, null); + } else { + if (unionIndex203 == 1) { + Utf8 charSequence203; + Object oldString203 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(203); + if (oldString203 instanceof Utf8) { + charSequence203 = (decoder).readString(((Utf8) oldString203)); + } else { + charSequence203 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(203, charSequence203); + } else { + throw new RuntimeException(("Illegal union index for 'F203': "+ unionIndex203)); + } + } + int unionIndex204 = (decoder.readIndex()); + if (unionIndex204 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(204, null); + } else { + if (unionIndex204 == 1) { + Utf8 charSequence204; + Object oldString204 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(204); + if (oldString204 instanceof Utf8) { + charSequence204 = (decoder).readString(((Utf8) oldString204)); + } else { + charSequence204 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(204, charSequence204); + } else { + throw new RuntimeException(("Illegal union index for 'F204': "+ unionIndex204)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex205 = (decoder.readIndex()); + if (unionIndex205 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(205, null); + } else { + if (unionIndex205 == 1) { + Utf8 charSequence205; + Object oldString205 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(205); + if (oldString205 instanceof Utf8) { + charSequence205 = (decoder).readString(((Utf8) oldString205)); + } else { + charSequence205 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(205, charSequence205); + } else { + throw new RuntimeException(("Illegal union index for 'F205': "+ unionIndex205)); + } + } + int unionIndex206 = (decoder.readIndex()); + if (unionIndex206 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(206, null); + } else { + if (unionIndex206 == 1) { + Utf8 charSequence206; + Object oldString206 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(206); + if (oldString206 instanceof Utf8) { + charSequence206 = (decoder).readString(((Utf8) oldString206)); + } else { + charSequence206 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(206, charSequence206); + } else { + throw new RuntimeException(("Illegal union index for 'F206': "+ unionIndex206)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex207 = (decoder.readIndex()); + if (unionIndex207 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(207, null); + } else { + if (unionIndex207 == 1) { + Utf8 charSequence207; + Object oldString207 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(207); + if (oldString207 instanceof Utf8) { + charSequence207 = (decoder).readString(((Utf8) oldString207)); + } else { + charSequence207 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(207, charSequence207); + } else { + throw new RuntimeException(("Illegal union index for 'F207': "+ unionIndex207)); + } + } + int unionIndex208 = (decoder.readIndex()); + if (unionIndex208 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(208, null); + } else { + if (unionIndex208 == 1) { + Utf8 charSequence208; + Object oldString208 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(208); + if (oldString208 instanceof Utf8) { + charSequence208 = (decoder).readString(((Utf8) oldString208)); + } else { + charSequence208 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(208, charSequence208); + } else { + throw new RuntimeException(("Illegal union index for 'F208': "+ unionIndex208)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex209 = (decoder.readIndex()); + if (unionIndex209 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(209, null); + } else { + if (unionIndex209 == 1) { + Utf8 charSequence209; + Object oldString209 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(209); + if (oldString209 instanceof Utf8) { + charSequence209 = (decoder).readString(((Utf8) oldString209)); + } else { + charSequence209 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(209, charSequence209); + } else { + throw new RuntimeException(("Illegal union index for 'F209': "+ unionIndex209)); + } + } + int unionIndex210 = (decoder.readIndex()); + if (unionIndex210 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(210, null); + } else { + if (unionIndex210 == 1) { + Utf8 charSequence210; + Object oldString210 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(210); + if (oldString210 instanceof Utf8) { + charSequence210 = (decoder).readString(((Utf8) oldString210)); + } else { + charSequence210 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(210, charSequence210); + } else { + throw new RuntimeException(("Illegal union index for 'F210': "+ unionIndex210)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex211 = (decoder.readIndex()); + if (unionIndex211 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(211, null); + } else { + if (unionIndex211 == 1) { + Utf8 charSequence211; + Object oldString211 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(211); + if (oldString211 instanceof Utf8) { + charSequence211 = (decoder).readString(((Utf8) oldString211)); + } else { + charSequence211 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(211, charSequence211); + } else { + throw new RuntimeException(("Illegal union index for 'F211': "+ unionIndex211)); + } + } + int unionIndex212 = (decoder.readIndex()); + if (unionIndex212 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(212, null); + } else { + if (unionIndex212 == 1) { + Utf8 charSequence212; + Object oldString212 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(212); + if (oldString212 instanceof Utf8) { + charSequence212 = (decoder).readString(((Utf8) oldString212)); + } else { + charSequence212 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(212, charSequence212); + } else { + throw new RuntimeException(("Illegal union index for 'F212': "+ unionIndex212)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex213 = (decoder.readIndex()); + if (unionIndex213 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(213, null); + } else { + if (unionIndex213 == 1) { + Utf8 charSequence213; + Object oldString213 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(213); + if (oldString213 instanceof Utf8) { + charSequence213 = (decoder).readString(((Utf8) oldString213)); + } else { + charSequence213 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(213, charSequence213); + } else { + throw new RuntimeException(("Illegal union index for 'F213': "+ unionIndex213)); + } + } + int unionIndex214 = (decoder.readIndex()); + if (unionIndex214 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(214, null); + } else { + if (unionIndex214 == 1) { + Utf8 charSequence214; + Object oldString214 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(214); + if (oldString214 instanceof Utf8) { + charSequence214 = (decoder).readString(((Utf8) oldString214)); + } else { + charSequence214 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(214, charSequence214); + } else { + throw new RuntimeException(("Illegal union index for 'F214': "+ unionIndex214)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex215 = (decoder.readIndex()); + if (unionIndex215 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(215, null); + } else { + if (unionIndex215 == 1) { + Utf8 charSequence215; + Object oldString215 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(215); + if (oldString215 instanceof Utf8) { + charSequence215 = (decoder).readString(((Utf8) oldString215)); + } else { + charSequence215 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(215, charSequence215); + } else { + throw new RuntimeException(("Illegal union index for 'F215': "+ unionIndex215)); + } + } + int unionIndex216 = (decoder.readIndex()); + if (unionIndex216 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(216, null); + } else { + if (unionIndex216 == 1) { + Utf8 charSequence216; + Object oldString216 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(216); + if (oldString216 instanceof Utf8) { + charSequence216 = (decoder).readString(((Utf8) oldString216)); + } else { + charSequence216 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(216, charSequence216); + } else { + throw new RuntimeException(("Illegal union index for 'F216': "+ unionIndex216)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex217 = (decoder.readIndex()); + if (unionIndex217 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(217, null); + } else { + if (unionIndex217 == 1) { + Utf8 charSequence217; + Object oldString217 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(217); + if (oldString217 instanceof Utf8) { + charSequence217 = (decoder).readString(((Utf8) oldString217)); + } else { + charSequence217 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(217, charSequence217); + } else { + throw new RuntimeException(("Illegal union index for 'F217': "+ unionIndex217)); + } + } + int unionIndex218 = (decoder.readIndex()); + if (unionIndex218 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(218, null); + } else { + if (unionIndex218 == 1) { + Utf8 charSequence218; + Object oldString218 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(218); + if (oldString218 instanceof Utf8) { + charSequence218 = (decoder).readString(((Utf8) oldString218)); + } else { + charSequence218 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(218, charSequence218); + } else { + throw new RuntimeException(("Illegal union index for 'F218': "+ unionIndex218)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex219 = (decoder.readIndex()); + if (unionIndex219 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(219, null); + } else { + if (unionIndex219 == 1) { + Utf8 charSequence219; + Object oldString219 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(219); + if (oldString219 instanceof Utf8) { + charSequence219 = (decoder).readString(((Utf8) oldString219)); + } else { + charSequence219 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(219, charSequence219); + } else { + throw new RuntimeException(("Illegal union index for 'F219': "+ unionIndex219)); + } + } + int unionIndex220 = (decoder.readIndex()); + if (unionIndex220 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(220, null); + } else { + if (unionIndex220 == 1) { + Utf8 charSequence220; + Object oldString220 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(220); + if (oldString220 instanceof Utf8) { + charSequence220 = (decoder).readString(((Utf8) oldString220)); + } else { + charSequence220 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(220, charSequence220); + } else { + throw new RuntimeException(("Illegal union index for 'F220': "+ unionIndex220)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex221 = (decoder.readIndex()); + if (unionIndex221 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(221, null); + } else { + if (unionIndex221 == 1) { + Utf8 charSequence221; + Object oldString221 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(221); + if (oldString221 instanceof Utf8) { + charSequence221 = (decoder).readString(((Utf8) oldString221)); + } else { + charSequence221 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(221, charSequence221); + } else { + throw new RuntimeException(("Illegal union index for 'F221': "+ unionIndex221)); + } + } + int unionIndex222 = (decoder.readIndex()); + if (unionIndex222 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(222, null); + } else { + if (unionIndex222 == 1) { + Utf8 charSequence222; + Object oldString222 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(222); + if (oldString222 instanceof Utf8) { + charSequence222 = (decoder).readString(((Utf8) oldString222)); + } else { + charSequence222 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(222, charSequence222); + } else { + throw new RuntimeException(("Illegal union index for 'F222': "+ unionIndex222)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex223 = (decoder.readIndex()); + if (unionIndex223 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(223, null); + } else { + if (unionIndex223 == 1) { + Utf8 charSequence223; + Object oldString223 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(223); + if (oldString223 instanceof Utf8) { + charSequence223 = (decoder).readString(((Utf8) oldString223)); + } else { + charSequence223 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(223, charSequence223); + } else { + throw new RuntimeException(("Illegal union index for 'F223': "+ unionIndex223)); + } + } + int unionIndex224 = (decoder.readIndex()); + if (unionIndex224 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(224, null); + } else { + if (unionIndex224 == 1) { + Utf8 charSequence224; + Object oldString224 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(224); + if (oldString224 instanceof Utf8) { + charSequence224 = (decoder).readString(((Utf8) oldString224)); + } else { + charSequence224 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(224, charSequence224); + } else { + throw new RuntimeException(("Illegal union index for 'F224': "+ unionIndex224)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex225 = (decoder.readIndex()); + if (unionIndex225 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(225, null); + } else { + if (unionIndex225 == 1) { + Utf8 charSequence225; + Object oldString225 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(225); + if (oldString225 instanceof Utf8) { + charSequence225 = (decoder).readString(((Utf8) oldString225)); + } else { + charSequence225 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(225, charSequence225); + } else { + throw new RuntimeException(("Illegal union index for 'F225': "+ unionIndex225)); + } + } + int unionIndex226 = (decoder.readIndex()); + if (unionIndex226 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(226, null); + } else { + if (unionIndex226 == 1) { + Utf8 charSequence226; + Object oldString226 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(226); + if (oldString226 instanceof Utf8) { + charSequence226 = (decoder).readString(((Utf8) oldString226)); + } else { + charSequence226 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(226, charSequence226); + } else { + throw new RuntimeException(("Illegal union index for 'F226': "+ unionIndex226)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex227 = (decoder.readIndex()); + if (unionIndex227 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(227, null); + } else { + if (unionIndex227 == 1) { + Utf8 charSequence227; + Object oldString227 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(227); + if (oldString227 instanceof Utf8) { + charSequence227 = (decoder).readString(((Utf8) oldString227)); + } else { + charSequence227 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(227, charSequence227); + } else { + throw new RuntimeException(("Illegal union index for 'F227': "+ unionIndex227)); + } + } + int unionIndex228 = (decoder.readIndex()); + if (unionIndex228 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(228, null); + } else { + if (unionIndex228 == 1) { + Utf8 charSequence228; + Object oldString228 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(228); + if (oldString228 instanceof Utf8) { + charSequence228 = (decoder).readString(((Utf8) oldString228)); + } else { + charSequence228 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(228, charSequence228); + } else { + throw new RuntimeException(("Illegal union index for 'F228': "+ unionIndex228)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex229 = (decoder.readIndex()); + if (unionIndex229 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(229, null); + } else { + if (unionIndex229 == 1) { + Utf8 charSequence229; + Object oldString229 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(229); + if (oldString229 instanceof Utf8) { + charSequence229 = (decoder).readString(((Utf8) oldString229)); + } else { + charSequence229 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(229, charSequence229); + } else { + throw new RuntimeException(("Illegal union index for 'F229': "+ unionIndex229)); + } + } + int unionIndex230 = (decoder.readIndex()); + if (unionIndex230 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(230, null); + } else { + if (unionIndex230 == 1) { + Utf8 charSequence230; + Object oldString230 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(230); + if (oldString230 instanceof Utf8) { + charSequence230 = (decoder).readString(((Utf8) oldString230)); + } else { + charSequence230 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(230, charSequence230); + } else { + throw new RuntimeException(("Illegal union index for 'F230': "+ unionIndex230)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex231 = (decoder.readIndex()); + if (unionIndex231 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(231, null); + } else { + if (unionIndex231 == 1) { + Utf8 charSequence231; + Object oldString231 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(231); + if (oldString231 instanceof Utf8) { + charSequence231 = (decoder).readString(((Utf8) oldString231)); + } else { + charSequence231 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(231, charSequence231); + } else { + throw new RuntimeException(("Illegal union index for 'F231': "+ unionIndex231)); + } + } + int unionIndex232 = (decoder.readIndex()); + if (unionIndex232 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(232, null); + } else { + if (unionIndex232 == 1) { + Utf8 charSequence232; + Object oldString232 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(232); + if (oldString232 instanceof Utf8) { + charSequence232 = (decoder).readString(((Utf8) oldString232)); + } else { + charSequence232 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(232, charSequence232); + } else { + throw new RuntimeException(("Illegal union index for 'F232': "+ unionIndex232)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex233 = (decoder.readIndex()); + if (unionIndex233 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(233, null); + } else { + if (unionIndex233 == 1) { + Utf8 charSequence233; + Object oldString233 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(233); + if (oldString233 instanceof Utf8) { + charSequence233 = (decoder).readString(((Utf8) oldString233)); + } else { + charSequence233 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(233, charSequence233); + } else { + throw new RuntimeException(("Illegal union index for 'F233': "+ unionIndex233)); + } + } + int unionIndex234 = (decoder.readIndex()); + if (unionIndex234 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(234, null); + } else { + if (unionIndex234 == 1) { + Utf8 charSequence234; + Object oldString234 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(234); + if (oldString234 instanceof Utf8) { + charSequence234 = (decoder).readString(((Utf8) oldString234)); + } else { + charSequence234 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(234, charSequence234); + } else { + throw new RuntimeException(("Illegal union index for 'F234': "+ unionIndex234)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex235 = (decoder.readIndex()); + if (unionIndex235 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(235, null); + } else { + if (unionIndex235 == 1) { + Utf8 charSequence235; + Object oldString235 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(235); + if (oldString235 instanceof Utf8) { + charSequence235 = (decoder).readString(((Utf8) oldString235)); + } else { + charSequence235 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(235, charSequence235); + } else { + throw new RuntimeException(("Illegal union index for 'F235': "+ unionIndex235)); + } + } + int unionIndex236 = (decoder.readIndex()); + if (unionIndex236 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(236, null); + } else { + if (unionIndex236 == 1) { + Utf8 charSequence236; + Object oldString236 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(236); + if (oldString236 instanceof Utf8) { + charSequence236 = (decoder).readString(((Utf8) oldString236)); + } else { + charSequence236 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(236, charSequence236); + } else { + throw new RuntimeException(("Illegal union index for 'F236': "+ unionIndex236)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex237 = (decoder.readIndex()); + if (unionIndex237 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(237, null); + } else { + if (unionIndex237 == 1) { + Utf8 charSequence237; + Object oldString237 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(237); + if (oldString237 instanceof Utf8) { + charSequence237 = (decoder).readString(((Utf8) oldString237)); + } else { + charSequence237 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(237, charSequence237); + } else { + throw new RuntimeException(("Illegal union index for 'F237': "+ unionIndex237)); + } + } + int unionIndex238 = (decoder.readIndex()); + if (unionIndex238 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(238, null); + } else { + if (unionIndex238 == 1) { + Utf8 charSequence238; + Object oldString238 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(238); + if (oldString238 instanceof Utf8) { + charSequence238 = (decoder).readString(((Utf8) oldString238)); + } else { + charSequence238 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(238, charSequence238); + } else { + throw new RuntimeException(("Illegal union index for 'F238': "+ unionIndex238)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex239 = (decoder.readIndex()); + if (unionIndex239 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(239, null); + } else { + if (unionIndex239 == 1) { + Utf8 charSequence239; + Object oldString239 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(239); + if (oldString239 instanceof Utf8) { + charSequence239 = (decoder).readString(((Utf8) oldString239)); + } else { + charSequence239 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(239, charSequence239); + } else { + throw new RuntimeException(("Illegal union index for 'F239': "+ unionIndex239)); + } + } + int unionIndex240 = (decoder.readIndex()); + if (unionIndex240 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(240, null); + } else { + if (unionIndex240 == 1) { + Utf8 charSequence240; + Object oldString240 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(240); + if (oldString240 instanceof Utf8) { + charSequence240 = (decoder).readString(((Utf8) oldString240)); + } else { + charSequence240 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(240, charSequence240); + } else { + throw new RuntimeException(("Illegal union index for 'F240': "+ unionIndex240)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex241 = (decoder.readIndex()); + if (unionIndex241 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(241, null); + } else { + if (unionIndex241 == 1) { + Utf8 charSequence241; + Object oldString241 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(241); + if (oldString241 instanceof Utf8) { + charSequence241 = (decoder).readString(((Utf8) oldString241)); + } else { + charSequence241 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(241, charSequence241); + } else { + throw new RuntimeException(("Illegal union index for 'F241': "+ unionIndex241)); + } + } + int unionIndex242 = (decoder.readIndex()); + if (unionIndex242 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(242, null); + } else { + if (unionIndex242 == 1) { + Utf8 charSequence242; + Object oldString242 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(242); + if (oldString242 instanceof Utf8) { + charSequence242 = (decoder).readString(((Utf8) oldString242)); + } else { + charSequence242 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(242, charSequence242); + } else { + throw new RuntimeException(("Illegal union index for 'F242': "+ unionIndex242)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex243 = (decoder.readIndex()); + if (unionIndex243 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(243, null); + } else { + if (unionIndex243 == 1) { + Utf8 charSequence243; + Object oldString243 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(243); + if (oldString243 instanceof Utf8) { + charSequence243 = (decoder).readString(((Utf8) oldString243)); + } else { + charSequence243 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(243, charSequence243); + } else { + throw new RuntimeException(("Illegal union index for 'F243': "+ unionIndex243)); + } + } + int unionIndex244 = (decoder.readIndex()); + if (unionIndex244 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(244, null); + } else { + if (unionIndex244 == 1) { + Utf8 charSequence244; + Object oldString244 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(244); + if (oldString244 instanceof Utf8) { + charSequence244 = (decoder).readString(((Utf8) oldString244)); + } else { + charSequence244 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(244, charSequence244); + } else { + throw new RuntimeException(("Illegal union index for 'F244': "+ unionIndex244)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex245 = (decoder.readIndex()); + if (unionIndex245 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(245, null); + } else { + if (unionIndex245 == 1) { + Utf8 charSequence245; + Object oldString245 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(245); + if (oldString245 instanceof Utf8) { + charSequence245 = (decoder).readString(((Utf8) oldString245)); + } else { + charSequence245 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(245, charSequence245); + } else { + throw new RuntimeException(("Illegal union index for 'F245': "+ unionIndex245)); + } + } + int unionIndex246 = (decoder.readIndex()); + if (unionIndex246 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(246, null); + } else { + if (unionIndex246 == 1) { + Utf8 charSequence246; + Object oldString246 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(246); + if (oldString246 instanceof Utf8) { + charSequence246 = (decoder).readString(((Utf8) oldString246)); + } else { + charSequence246 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(246, charSequence246); + } else { + throw new RuntimeException(("Illegal union index for 'F246': "+ unionIndex246)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex247 = (decoder.readIndex()); + if (unionIndex247 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(247, null); + } else { + if (unionIndex247 == 1) { + Utf8 charSequence247; + Object oldString247 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(247); + if (oldString247 instanceof Utf8) { + charSequence247 = (decoder).readString(((Utf8) oldString247)); + } else { + charSequence247 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(247, charSequence247); + } else { + throw new RuntimeException(("Illegal union index for 'F247': "+ unionIndex247)); + } + } + int unionIndex248 = (decoder.readIndex()); + if (unionIndex248 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(248, null); + } else { + if (unionIndex248 == 1) { + Utf8 charSequence248; + Object oldString248 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(248); + if (oldString248 instanceof Utf8) { + charSequence248 = (decoder).readString(((Utf8) oldString248)); + } else { + charSequence248 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(248, charSequence248); + } else { + throw new RuntimeException(("Illegal union index for 'F248': "+ unionIndex248)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex249 = (decoder.readIndex()); + if (unionIndex249 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(249, null); + } else { + if (unionIndex249 == 1) { + Utf8 charSequence249; + Object oldString249 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(249); + if (oldString249 instanceof Utf8) { + charSequence249 = (decoder).readString(((Utf8) oldString249)); + } else { + charSequence249 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(249, charSequence249); + } else { + throw new RuntimeException(("Illegal union index for 'F249': "+ unionIndex249)); + } + } + int unionIndex250 = (decoder.readIndex()); + if (unionIndex250 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(250, null); + } else { + if (unionIndex250 == 1) { + Utf8 charSequence250; + Object oldString250 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(250); + if (oldString250 instanceof Utf8) { + charSequence250 = (decoder).readString(((Utf8) oldString250)); + } else { + charSequence250 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(250, charSequence250); + } else { + throw new RuntimeException(("Illegal union index for 'F250': "+ unionIndex250)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex251 = (decoder.readIndex()); + if (unionIndex251 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(251, null); + } else { + if (unionIndex251 == 1) { + Utf8 charSequence251; + Object oldString251 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(251); + if (oldString251 instanceof Utf8) { + charSequence251 = (decoder).readString(((Utf8) oldString251)); + } else { + charSequence251 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(251, charSequence251); + } else { + throw new RuntimeException(("Illegal union index for 'F251': "+ unionIndex251)); + } + } + int unionIndex252 = (decoder.readIndex()); + if (unionIndex252 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(252, null); + } else { + if (unionIndex252 == 1) { + Utf8 charSequence252; + Object oldString252 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(252); + if (oldString252 instanceof Utf8) { + charSequence252 = (decoder).readString(((Utf8) oldString252)); + } else { + charSequence252 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(252, charSequence252); + } else { + throw new RuntimeException(("Illegal union index for 'F252': "+ unionIndex252)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex253 = (decoder.readIndex()); + if (unionIndex253 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(253, null); + } else { + if (unionIndex253 == 1) { + Utf8 charSequence253; + Object oldString253 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(253); + if (oldString253 instanceof Utf8) { + charSequence253 = (decoder).readString(((Utf8) oldString253)); + } else { + charSequence253 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(253, charSequence253); + } else { + throw new RuntimeException(("Illegal union index for 'F253': "+ unionIndex253)); + } + } + int unionIndex254 = (decoder.readIndex()); + if (unionIndex254 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(254, null); + } else { + if (unionIndex254 == 1) { + Utf8 charSequence254; + Object oldString254 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(254); + if (oldString254 instanceof Utf8) { + charSequence254 = (decoder).readString(((Utf8) oldString254)); + } else { + charSequence254 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(254, charSequence254); + } else { + throw new RuntimeException(("Illegal union index for 'F254': "+ unionIndex254)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex255 = (decoder.readIndex()); + if (unionIndex255 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(255, null); + } else { + if (unionIndex255 == 1) { + Utf8 charSequence255; + Object oldString255 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(255); + if (oldString255 instanceof Utf8) { + charSequence255 = (decoder).readString(((Utf8) oldString255)); + } else { + charSequence255 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(255, charSequence255); + } else { + throw new RuntimeException(("Illegal union index for 'F255': "+ unionIndex255)); + } + } + int unionIndex256 = (decoder.readIndex()); + if (unionIndex256 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(256, null); + } else { + if (unionIndex256 == 1) { + Utf8 charSequence256; + Object oldString256 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(256); + if (oldString256 instanceof Utf8) { + charSequence256 = (decoder).readString(((Utf8) oldString256)); + } else { + charSequence256 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(256, charSequence256); + } else { + throw new RuntimeException(("Illegal union index for 'F256': "+ unionIndex256)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex257 = (decoder.readIndex()); + if (unionIndex257 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(257, null); + } else { + if (unionIndex257 == 1) { + Utf8 charSequence257; + Object oldString257 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(257); + if (oldString257 instanceof Utf8) { + charSequence257 = (decoder).readString(((Utf8) oldString257)); + } else { + charSequence257 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(257, charSequence257); + } else { + throw new RuntimeException(("Illegal union index for 'F257': "+ unionIndex257)); + } + } + int unionIndex258 = (decoder.readIndex()); + if (unionIndex258 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(258, null); + } else { + if (unionIndex258 == 1) { + Utf8 charSequence258; + Object oldString258 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(258); + if (oldString258 instanceof Utf8) { + charSequence258 = (decoder).readString(((Utf8) oldString258)); + } else { + charSequence258 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(258, charSequence258); + } else { + throw new RuntimeException(("Illegal union index for 'F258': "+ unionIndex258)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex259 = (decoder.readIndex()); + if (unionIndex259 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(259, null); + } else { + if (unionIndex259 == 1) { + Utf8 charSequence259; + Object oldString259 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(259); + if (oldString259 instanceof Utf8) { + charSequence259 = (decoder).readString(((Utf8) oldString259)); + } else { + charSequence259 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(259, charSequence259); + } else { + throw new RuntimeException(("Illegal union index for 'F259': "+ unionIndex259)); + } + } + int unionIndex260 = (decoder.readIndex()); + if (unionIndex260 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(260, null); + } else { + if (unionIndex260 == 1) { + Utf8 charSequence260; + Object oldString260 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(260); + if (oldString260 instanceof Utf8) { + charSequence260 = (decoder).readString(((Utf8) oldString260)); + } else { + charSequence260 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(260, charSequence260); + } else { + throw new RuntimeException(("Illegal union index for 'F260': "+ unionIndex260)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex261 = (decoder.readIndex()); + if (unionIndex261 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(261, null); + } else { + if (unionIndex261 == 1) { + Utf8 charSequence261; + Object oldString261 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(261); + if (oldString261 instanceof Utf8) { + charSequence261 = (decoder).readString(((Utf8) oldString261)); + } else { + charSequence261 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(261, charSequence261); + } else { + throw new RuntimeException(("Illegal union index for 'F261': "+ unionIndex261)); + } + } + int unionIndex262 = (decoder.readIndex()); + if (unionIndex262 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(262, null); + } else { + if (unionIndex262 == 1) { + Utf8 charSequence262; + Object oldString262 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(262); + if (oldString262 instanceof Utf8) { + charSequence262 = (decoder).readString(((Utf8) oldString262)); + } else { + charSequence262 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(262, charSequence262); + } else { + throw new RuntimeException(("Illegal union index for 'F262': "+ unionIndex262)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex263 = (decoder.readIndex()); + if (unionIndex263 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(263, null); + } else { + if (unionIndex263 == 1) { + Utf8 charSequence263; + Object oldString263 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(263); + if (oldString263 instanceof Utf8) { + charSequence263 = (decoder).readString(((Utf8) oldString263)); + } else { + charSequence263 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(263, charSequence263); + } else { + throw new RuntimeException(("Illegal union index for 'F263': "+ unionIndex263)); + } + } + int unionIndex264 = (decoder.readIndex()); + if (unionIndex264 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(264, null); + } else { + if (unionIndex264 == 1) { + Utf8 charSequence264; + Object oldString264 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(264); + if (oldString264 instanceof Utf8) { + charSequence264 = (decoder).readString(((Utf8) oldString264)); + } else { + charSequence264 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(264, charSequence264); + } else { + throw new RuntimeException(("Illegal union index for 'F264': "+ unionIndex264)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex265 = (decoder.readIndex()); + if (unionIndex265 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(265, null); + } else { + if (unionIndex265 == 1) { + Utf8 charSequence265; + Object oldString265 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(265); + if (oldString265 instanceof Utf8) { + charSequence265 = (decoder).readString(((Utf8) oldString265)); + } else { + charSequence265 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(265, charSequence265); + } else { + throw new RuntimeException(("Illegal union index for 'F265': "+ unionIndex265)); + } + } + int unionIndex266 = (decoder.readIndex()); + if (unionIndex266 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(266, null); + } else { + if (unionIndex266 == 1) { + Utf8 charSequence266; + Object oldString266 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(266); + if (oldString266 instanceof Utf8) { + charSequence266 = (decoder).readString(((Utf8) oldString266)); + } else { + charSequence266 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(266, charSequence266); + } else { + throw new RuntimeException(("Illegal union index for 'F266': "+ unionIndex266)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex267 = (decoder.readIndex()); + if (unionIndex267 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(267, null); + } else { + if (unionIndex267 == 1) { + Utf8 charSequence267; + Object oldString267 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(267); + if (oldString267 instanceof Utf8) { + charSequence267 = (decoder).readString(((Utf8) oldString267)); + } else { + charSequence267 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(267, charSequence267); + } else { + throw new RuntimeException(("Illegal union index for 'F267': "+ unionIndex267)); + } + } + int unionIndex268 = (decoder.readIndex()); + if (unionIndex268 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(268, null); + } else { + if (unionIndex268 == 1) { + Utf8 charSequence268; + Object oldString268 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(268); + if (oldString268 instanceof Utf8) { + charSequence268 = (decoder).readString(((Utf8) oldString268)); + } else { + charSequence268 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(268, charSequence268); + } else { + throw new RuntimeException(("Illegal union index for 'F268': "+ unionIndex268)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex269 = (decoder.readIndex()); + if (unionIndex269 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(269, null); + } else { + if (unionIndex269 == 1) { + Utf8 charSequence269; + Object oldString269 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(269); + if (oldString269 instanceof Utf8) { + charSequence269 = (decoder).readString(((Utf8) oldString269)); + } else { + charSequence269 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(269, charSequence269); + } else { + throw new RuntimeException(("Illegal union index for 'F269': "+ unionIndex269)); + } + } + int unionIndex270 = (decoder.readIndex()); + if (unionIndex270 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(270, null); + } else { + if (unionIndex270 == 1) { + Utf8 charSequence270; + Object oldString270 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(270); + if (oldString270 instanceof Utf8) { + charSequence270 = (decoder).readString(((Utf8) oldString270)); + } else { + charSequence270 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(270, charSequence270); + } else { + throw new RuntimeException(("Illegal union index for 'F270': "+ unionIndex270)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex271 = (decoder.readIndex()); + if (unionIndex271 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(271, null); + } else { + if (unionIndex271 == 1) { + Utf8 charSequence271; + Object oldString271 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(271); + if (oldString271 instanceof Utf8) { + charSequence271 = (decoder).readString(((Utf8) oldString271)); + } else { + charSequence271 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(271, charSequence271); + } else { + throw new RuntimeException(("Illegal union index for 'F271': "+ unionIndex271)); + } + } + int unionIndex272 = (decoder.readIndex()); + if (unionIndex272 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(272, null); + } else { + if (unionIndex272 == 1) { + Utf8 charSequence272; + Object oldString272 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(272); + if (oldString272 instanceof Utf8) { + charSequence272 = (decoder).readString(((Utf8) oldString272)); + } else { + charSequence272 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(272, charSequence272); + } else { + throw new RuntimeException(("Illegal union index for 'F272': "+ unionIndex272)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex273 = (decoder.readIndex()); + if (unionIndex273 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(273, null); + } else { + if (unionIndex273 == 1) { + Utf8 charSequence273; + Object oldString273 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(273); + if (oldString273 instanceof Utf8) { + charSequence273 = (decoder).readString(((Utf8) oldString273)); + } else { + charSequence273 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(273, charSequence273); + } else { + throw new RuntimeException(("Illegal union index for 'F273': "+ unionIndex273)); + } + } + int unionIndex274 = (decoder.readIndex()); + if (unionIndex274 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(274, null); + } else { + if (unionIndex274 == 1) { + Utf8 charSequence274; + Object oldString274 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(274); + if (oldString274 instanceof Utf8) { + charSequence274 = (decoder).readString(((Utf8) oldString274)); + } else { + charSequence274 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(274, charSequence274); + } else { + throw new RuntimeException(("Illegal union index for 'F274': "+ unionIndex274)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex275 = (decoder.readIndex()); + if (unionIndex275 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(275, null); + } else { + if (unionIndex275 == 1) { + Utf8 charSequence275; + Object oldString275 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(275); + if (oldString275 instanceof Utf8) { + charSequence275 = (decoder).readString(((Utf8) oldString275)); + } else { + charSequence275 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(275, charSequence275); + } else { + throw new RuntimeException(("Illegal union index for 'F275': "+ unionIndex275)); + } + } + int unionIndex276 = (decoder.readIndex()); + if (unionIndex276 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(276, null); + } else { + if (unionIndex276 == 1) { + Utf8 charSequence276; + Object oldString276 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(276); + if (oldString276 instanceof Utf8) { + charSequence276 = (decoder).readString(((Utf8) oldString276)); + } else { + charSequence276 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(276, charSequence276); + } else { + throw new RuntimeException(("Illegal union index for 'F276': "+ unionIndex276)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex277 = (decoder.readIndex()); + if (unionIndex277 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(277, null); + } else { + if (unionIndex277 == 1) { + Utf8 charSequence277; + Object oldString277 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(277); + if (oldString277 instanceof Utf8) { + charSequence277 = (decoder).readString(((Utf8) oldString277)); + } else { + charSequence277 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(277, charSequence277); + } else { + throw new RuntimeException(("Illegal union index for 'F277': "+ unionIndex277)); + } + } + int unionIndex278 = (decoder.readIndex()); + if (unionIndex278 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(278, null); + } else { + if (unionIndex278 == 1) { + Utf8 charSequence278; + Object oldString278 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(278); + if (oldString278 instanceof Utf8) { + charSequence278 = (decoder).readString(((Utf8) oldString278)); + } else { + charSequence278 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(278, charSequence278); + } else { + throw new RuntimeException(("Illegal union index for 'F278': "+ unionIndex278)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex279 = (decoder.readIndex()); + if (unionIndex279 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(279, null); + } else { + if (unionIndex279 == 1) { + Utf8 charSequence279; + Object oldString279 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(279); + if (oldString279 instanceof Utf8) { + charSequence279 = (decoder).readString(((Utf8) oldString279)); + } else { + charSequence279 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(279, charSequence279); + } else { + throw new RuntimeException(("Illegal union index for 'F279': "+ unionIndex279)); + } + } + int unionIndex280 = (decoder.readIndex()); + if (unionIndex280 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(280, null); + } else { + if (unionIndex280 == 1) { + Utf8 charSequence280; + Object oldString280 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(280); + if (oldString280 instanceof Utf8) { + charSequence280 = (decoder).readString(((Utf8) oldString280)); + } else { + charSequence280 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(280, charSequence280); + } else { + throw new RuntimeException(("Illegal union index for 'F280': "+ unionIndex280)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex281 = (decoder.readIndex()); + if (unionIndex281 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(281, null); + } else { + if (unionIndex281 == 1) { + Utf8 charSequence281; + Object oldString281 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(281); + if (oldString281 instanceof Utf8) { + charSequence281 = (decoder).readString(((Utf8) oldString281)); + } else { + charSequence281 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(281, charSequence281); + } else { + throw new RuntimeException(("Illegal union index for 'F281': "+ unionIndex281)); + } + } + int unionIndex282 = (decoder.readIndex()); + if (unionIndex282 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(282, null); + } else { + if (unionIndex282 == 1) { + Utf8 charSequence282; + Object oldString282 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(282); + if (oldString282 instanceof Utf8) { + charSequence282 = (decoder).readString(((Utf8) oldString282)); + } else { + charSequence282 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(282, charSequence282); + } else { + throw new RuntimeException(("Illegal union index for 'F282': "+ unionIndex282)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex283 = (decoder.readIndex()); + if (unionIndex283 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(283, null); + } else { + if (unionIndex283 == 1) { + Utf8 charSequence283; + Object oldString283 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(283); + if (oldString283 instanceof Utf8) { + charSequence283 = (decoder).readString(((Utf8) oldString283)); + } else { + charSequence283 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(283, charSequence283); + } else { + throw new RuntimeException(("Illegal union index for 'F283': "+ unionIndex283)); + } + } + int unionIndex284 = (decoder.readIndex()); + if (unionIndex284 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(284, null); + } else { + if (unionIndex284 == 1) { + Utf8 charSequence284; + Object oldString284 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(284); + if (oldString284 instanceof Utf8) { + charSequence284 = (decoder).readString(((Utf8) oldString284)); + } else { + charSequence284 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(284, charSequence284); + } else { + throw new RuntimeException(("Illegal union index for 'F284': "+ unionIndex284)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex285 = (decoder.readIndex()); + if (unionIndex285 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(285, null); + } else { + if (unionIndex285 == 1) { + Utf8 charSequence285; + Object oldString285 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(285); + if (oldString285 instanceof Utf8) { + charSequence285 = (decoder).readString(((Utf8) oldString285)); + } else { + charSequence285 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(285, charSequence285); + } else { + throw new RuntimeException(("Illegal union index for 'F285': "+ unionIndex285)); + } + } + int unionIndex286 = (decoder.readIndex()); + if (unionIndex286 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(286, null); + } else { + if (unionIndex286 == 1) { + Utf8 charSequence286; + Object oldString286 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(286); + if (oldString286 instanceof Utf8) { + charSequence286 = (decoder).readString(((Utf8) oldString286)); + } else { + charSequence286 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(286, charSequence286); + } else { + throw new RuntimeException(("Illegal union index for 'F286': "+ unionIndex286)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex287 = (decoder.readIndex()); + if (unionIndex287 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(287, null); + } else { + if (unionIndex287 == 1) { + Utf8 charSequence287; + Object oldString287 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(287); + if (oldString287 instanceof Utf8) { + charSequence287 = (decoder).readString(((Utf8) oldString287)); + } else { + charSequence287 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(287, charSequence287); + } else { + throw new RuntimeException(("Illegal union index for 'F287': "+ unionIndex287)); + } + } + int unionIndex288 = (decoder.readIndex()); + if (unionIndex288 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(288, null); + } else { + if (unionIndex288 == 1) { + Utf8 charSequence288; + Object oldString288 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(288); + if (oldString288 instanceof Utf8) { + charSequence288 = (decoder).readString(((Utf8) oldString288)); + } else { + charSequence288 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(288, charSequence288); + } else { + throw new RuntimeException(("Illegal union index for 'F288': "+ unionIndex288)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex289 = (decoder.readIndex()); + if (unionIndex289 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(289, null); + } else { + if (unionIndex289 == 1) { + Utf8 charSequence289; + Object oldString289 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(289); + if (oldString289 instanceof Utf8) { + charSequence289 = (decoder).readString(((Utf8) oldString289)); + } else { + charSequence289 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(289, charSequence289); + } else { + throw new RuntimeException(("Illegal union index for 'F289': "+ unionIndex289)); + } + } + int unionIndex290 = (decoder.readIndex()); + if (unionIndex290 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(290, null); + } else { + if (unionIndex290 == 1) { + Utf8 charSequence290; + Object oldString290 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(290); + if (oldString290 instanceof Utf8) { + charSequence290 = (decoder).readString(((Utf8) oldString290)); + } else { + charSequence290 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(290, charSequence290); + } else { + throw new RuntimeException(("Illegal union index for 'F290': "+ unionIndex290)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex291 = (decoder.readIndex()); + if (unionIndex291 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(291, null); + } else { + if (unionIndex291 == 1) { + Utf8 charSequence291; + Object oldString291 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(291); + if (oldString291 instanceof Utf8) { + charSequence291 = (decoder).readString(((Utf8) oldString291)); + } else { + charSequence291 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(291, charSequence291); + } else { + throw new RuntimeException(("Illegal union index for 'F291': "+ unionIndex291)); + } + } + int unionIndex292 = (decoder.readIndex()); + if (unionIndex292 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(292, null); + } else { + if (unionIndex292 == 1) { + Utf8 charSequence292; + Object oldString292 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(292); + if (oldString292 instanceof Utf8) { + charSequence292 = (decoder).readString(((Utf8) oldString292)); + } else { + charSequence292 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(292, charSequence292); + } else { + throw new RuntimeException(("Illegal union index for 'F292': "+ unionIndex292)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex293 = (decoder.readIndex()); + if (unionIndex293 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(293, null); + } else { + if (unionIndex293 == 1) { + Utf8 charSequence293; + Object oldString293 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(293); + if (oldString293 instanceof Utf8) { + charSequence293 = (decoder).readString(((Utf8) oldString293)); + } else { + charSequence293 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(293, charSequence293); + } else { + throw new RuntimeException(("Illegal union index for 'F293': "+ unionIndex293)); + } + } + int unionIndex294 = (decoder.readIndex()); + if (unionIndex294 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(294, null); + } else { + if (unionIndex294 == 1) { + Utf8 charSequence294; + Object oldString294 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(294); + if (oldString294 instanceof Utf8) { + charSequence294 = (decoder).readString(((Utf8) oldString294)); + } else { + charSequence294 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(294, charSequence294); + } else { + throw new RuntimeException(("Illegal union index for 'F294': "+ unionIndex294)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex295 = (decoder.readIndex()); + if (unionIndex295 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(295, null); + } else { + if (unionIndex295 == 1) { + Utf8 charSequence295; + Object oldString295 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(295); + if (oldString295 instanceof Utf8) { + charSequence295 = (decoder).readString(((Utf8) oldString295)); + } else { + charSequence295 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(295, charSequence295); + } else { + throw new RuntimeException(("Illegal union index for 'F295': "+ unionIndex295)); + } + } + int unionIndex296 = (decoder.readIndex()); + if (unionIndex296 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(296, null); + } else { + if (unionIndex296 == 1) { + Utf8 charSequence296; + Object oldString296 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(296); + if (oldString296 instanceof Utf8) { + charSequence296 = (decoder).readString(((Utf8) oldString296)); + } else { + charSequence296 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(296, charSequence296); + } else { + throw new RuntimeException(("Illegal union index for 'F296': "+ unionIndex296)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex297 = (decoder.readIndex()); + if (unionIndex297 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(297, null); + } else { + if (unionIndex297 == 1) { + Utf8 charSequence297; + Object oldString297 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(297); + if (oldString297 instanceof Utf8) { + charSequence297 = (decoder).readString(((Utf8) oldString297)); + } else { + charSequence297 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(297, charSequence297); + } else { + throw new RuntimeException(("Illegal union index for 'F297': "+ unionIndex297)); + } + } + int unionIndex298 = (decoder.readIndex()); + if (unionIndex298 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(298, null); + } else { + if (unionIndex298 == 1) { + Utf8 charSequence298; + Object oldString298 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(298); + if (oldString298 instanceof Utf8) { + charSequence298 = (decoder).readString(((Utf8) oldString298)); + } else { + charSequence298 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(298, charSequence298); + } else { + throw new RuntimeException(("Illegal union index for 'F298': "+ unionIndex298)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex299 = (decoder.readIndex()); + if (unionIndex299 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(299, null); + } else { + if (unionIndex299 == 1) { + Utf8 charSequence299; + Object oldString299 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(299); + if (oldString299 instanceof Utf8) { + charSequence299 = (decoder).readString(((Utf8) oldString299)); + } else { + charSequence299 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(299, charSequence299); + } else { + throw new RuntimeException(("Illegal union index for 'F299': "+ unionIndex299)); + } + } + int unionIndex300 = (decoder.readIndex()); + if (unionIndex300 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(300, null); + } else { + if (unionIndex300 == 1) { + Utf8 charSequence300; + Object oldString300 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(300); + if (oldString300 instanceof Utf8) { + charSequence300 = (decoder).readString(((Utf8) oldString300)); + } else { + charSequence300 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(300, charSequence300); + } else { + throw new RuntimeException(("Illegal union index for 'F300': "+ unionIndex300)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex301 = (decoder.readIndex()); + if (unionIndex301 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(301, null); + } else { + if (unionIndex301 == 1) { + Utf8 charSequence301; + Object oldString301 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(301); + if (oldString301 instanceof Utf8) { + charSequence301 = (decoder).readString(((Utf8) oldString301)); + } else { + charSequence301 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(301, charSequence301); + } else { + throw new RuntimeException(("Illegal union index for 'F301': "+ unionIndex301)); + } + } + int unionIndex302 = (decoder.readIndex()); + if (unionIndex302 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(302, null); + } else { + if (unionIndex302 == 1) { + Utf8 charSequence302; + Object oldString302 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(302); + if (oldString302 instanceof Utf8) { + charSequence302 = (decoder).readString(((Utf8) oldString302)); + } else { + charSequence302 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(302, charSequence302); + } else { + throw new RuntimeException(("Illegal union index for 'F302': "+ unionIndex302)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex303 = (decoder.readIndex()); + if (unionIndex303 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(303, null); + } else { + if (unionIndex303 == 1) { + Utf8 charSequence303; + Object oldString303 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(303); + if (oldString303 instanceof Utf8) { + charSequence303 = (decoder).readString(((Utf8) oldString303)); + } else { + charSequence303 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(303, charSequence303); + } else { + throw new RuntimeException(("Illegal union index for 'F303': "+ unionIndex303)); + } + } + int unionIndex304 = (decoder.readIndex()); + if (unionIndex304 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(304, null); + } else { + if (unionIndex304 == 1) { + Utf8 charSequence304; + Object oldString304 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(304); + if (oldString304 instanceof Utf8) { + charSequence304 = (decoder).readString(((Utf8) oldString304)); + } else { + charSequence304 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(304, charSequence304); + } else { + throw new RuntimeException(("Illegal union index for 'F304': "+ unionIndex304)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex305 = (decoder.readIndex()); + if (unionIndex305 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(305, null); + } else { + if (unionIndex305 == 1) { + Utf8 charSequence305; + Object oldString305 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(305); + if (oldString305 instanceof Utf8) { + charSequence305 = (decoder).readString(((Utf8) oldString305)); + } else { + charSequence305 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(305, charSequence305); + } else { + throw new RuntimeException(("Illegal union index for 'F305': "+ unionIndex305)); + } + } + int unionIndex306 = (decoder.readIndex()); + if (unionIndex306 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(306, null); + } else { + if (unionIndex306 == 1) { + Utf8 charSequence306; + Object oldString306 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(306); + if (oldString306 instanceof Utf8) { + charSequence306 = (decoder).readString(((Utf8) oldString306)); + } else { + charSequence306 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(306, charSequence306); + } else { + throw new RuntimeException(("Illegal union index for 'F306': "+ unionIndex306)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex307 = (decoder.readIndex()); + if (unionIndex307 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(307, null); + } else { + if (unionIndex307 == 1) { + Utf8 charSequence307; + Object oldString307 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(307); + if (oldString307 instanceof Utf8) { + charSequence307 = (decoder).readString(((Utf8) oldString307)); + } else { + charSequence307 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(307, charSequence307); + } else { + throw new RuntimeException(("Illegal union index for 'F307': "+ unionIndex307)); + } + } + int unionIndex308 = (decoder.readIndex()); + if (unionIndex308 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(308, null); + } else { + if (unionIndex308 == 1) { + Utf8 charSequence308; + Object oldString308 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(308); + if (oldString308 instanceof Utf8) { + charSequence308 = (decoder).readString(((Utf8) oldString308)); + } else { + charSequence308 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(308, charSequence308); + } else { + throw new RuntimeException(("Illegal union index for 'F308': "+ unionIndex308)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex309 = (decoder.readIndex()); + if (unionIndex309 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(309, null); + } else { + if (unionIndex309 == 1) { + Utf8 charSequence309; + Object oldString309 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(309); + if (oldString309 instanceof Utf8) { + charSequence309 = (decoder).readString(((Utf8) oldString309)); + } else { + charSequence309 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(309, charSequence309); + } else { + throw new RuntimeException(("Illegal union index for 'F309': "+ unionIndex309)); + } + } + int unionIndex310 = (decoder.readIndex()); + if (unionIndex310 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(310, null); + } else { + if (unionIndex310 == 1) { + Utf8 charSequence310; + Object oldString310 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(310); + if (oldString310 instanceof Utf8) { + charSequence310 = (decoder).readString(((Utf8) oldString310)); + } else { + charSequence310 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(310, charSequence310); + } else { + throw new RuntimeException(("Illegal union index for 'F310': "+ unionIndex310)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex311 = (decoder.readIndex()); + if (unionIndex311 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(311, null); + } else { + if (unionIndex311 == 1) { + Utf8 charSequence311; + Object oldString311 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(311); + if (oldString311 instanceof Utf8) { + charSequence311 = (decoder).readString(((Utf8) oldString311)); + } else { + charSequence311 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(311, charSequence311); + } else { + throw new RuntimeException(("Illegal union index for 'F311': "+ unionIndex311)); + } + } + int unionIndex312 = (decoder.readIndex()); + if (unionIndex312 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(312, null); + } else { + if (unionIndex312 == 1) { + Utf8 charSequence312; + Object oldString312 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(312); + if (oldString312 instanceof Utf8) { + charSequence312 = (decoder).readString(((Utf8) oldString312)); + } else { + charSequence312 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(312, charSequence312); + } else { + throw new RuntimeException(("Illegal union index for 'F312': "+ unionIndex312)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex313 = (decoder.readIndex()); + if (unionIndex313 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(313, null); + } else { + if (unionIndex313 == 1) { + Utf8 charSequence313; + Object oldString313 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(313); + if (oldString313 instanceof Utf8) { + charSequence313 = (decoder).readString(((Utf8) oldString313)); + } else { + charSequence313 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(313, charSequence313); + } else { + throw new RuntimeException(("Illegal union index for 'F313': "+ unionIndex313)); + } + } + int unionIndex314 = (decoder.readIndex()); + if (unionIndex314 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(314, null); + } else { + if (unionIndex314 == 1) { + Utf8 charSequence314; + Object oldString314 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(314); + if (oldString314 instanceof Utf8) { + charSequence314 = (decoder).readString(((Utf8) oldString314)); + } else { + charSequence314 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(314, charSequence314); + } else { + throw new RuntimeException(("Illegal union index for 'F314': "+ unionIndex314)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex315 = (decoder.readIndex()); + if (unionIndex315 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(315, null); + } else { + if (unionIndex315 == 1) { + Utf8 charSequence315; + Object oldString315 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(315); + if (oldString315 instanceof Utf8) { + charSequence315 = (decoder).readString(((Utf8) oldString315)); + } else { + charSequence315 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(315, charSequence315); + } else { + throw new RuntimeException(("Illegal union index for 'F315': "+ unionIndex315)); + } + } + int unionIndex316 = (decoder.readIndex()); + if (unionIndex316 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(316, null); + } else { + if (unionIndex316 == 1) { + Utf8 charSequence316; + Object oldString316 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(316); + if (oldString316 instanceof Utf8) { + charSequence316 = (decoder).readString(((Utf8) oldString316)); + } else { + charSequence316 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(316, charSequence316); + } else { + throw new RuntimeException(("Illegal union index for 'F316': "+ unionIndex316)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex317 = (decoder.readIndex()); + if (unionIndex317 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(317, null); + } else { + if (unionIndex317 == 1) { + Utf8 charSequence317; + Object oldString317 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(317); + if (oldString317 instanceof Utf8) { + charSequence317 = (decoder).readString(((Utf8) oldString317)); + } else { + charSequence317 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(317, charSequence317); + } else { + throw new RuntimeException(("Illegal union index for 'F317': "+ unionIndex317)); + } + } + int unionIndex318 = (decoder.readIndex()); + if (unionIndex318 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(318, null); + } else { + if (unionIndex318 == 1) { + Utf8 charSequence318; + Object oldString318 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(318); + if (oldString318 instanceof Utf8) { + charSequence318 = (decoder).readString(((Utf8) oldString318)); + } else { + charSequence318 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(318, charSequence318); + } else { + throw new RuntimeException(("Illegal union index for 'F318': "+ unionIndex318)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex319 = (decoder.readIndex()); + if (unionIndex319 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(319, null); + } else { + if (unionIndex319 == 1) { + Utf8 charSequence319; + Object oldString319 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(319); + if (oldString319 instanceof Utf8) { + charSequence319 = (decoder).readString(((Utf8) oldString319)); + } else { + charSequence319 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(319, charSequence319); + } else { + throw new RuntimeException(("Illegal union index for 'F319': "+ unionIndex319)); + } + } + int unionIndex320 = (decoder.readIndex()); + if (unionIndex320 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(320, null); + } else { + if (unionIndex320 == 1) { + Utf8 charSequence320; + Object oldString320 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(320); + if (oldString320 instanceof Utf8) { + charSequence320 = (decoder).readString(((Utf8) oldString320)); + } else { + charSequence320 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(320, charSequence320); + } else { + throw new RuntimeException(("Illegal union index for 'F320': "+ unionIndex320)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex321 = (decoder.readIndex()); + if (unionIndex321 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(321, null); + } else { + if (unionIndex321 == 1) { + Utf8 charSequence321; + Object oldString321 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(321); + if (oldString321 instanceof Utf8) { + charSequence321 = (decoder).readString(((Utf8) oldString321)); + } else { + charSequence321 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(321, charSequence321); + } else { + throw new RuntimeException(("Illegal union index for 'F321': "+ unionIndex321)); + } + } + int unionIndex322 = (decoder.readIndex()); + if (unionIndex322 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(322, null); + } else { + if (unionIndex322 == 1) { + Utf8 charSequence322; + Object oldString322 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(322); + if (oldString322 instanceof Utf8) { + charSequence322 = (decoder).readString(((Utf8) oldString322)); + } else { + charSequence322 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(322, charSequence322); + } else { + throw new RuntimeException(("Illegal union index for 'F322': "+ unionIndex322)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex323 = (decoder.readIndex()); + if (unionIndex323 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(323, null); + } else { + if (unionIndex323 == 1) { + Utf8 charSequence323; + Object oldString323 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(323); + if (oldString323 instanceof Utf8) { + charSequence323 = (decoder).readString(((Utf8) oldString323)); + } else { + charSequence323 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(323, charSequence323); + } else { + throw new RuntimeException(("Illegal union index for 'F323': "+ unionIndex323)); + } + } + int unionIndex324 = (decoder.readIndex()); + if (unionIndex324 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(324, null); + } else { + if (unionIndex324 == 1) { + Utf8 charSequence324; + Object oldString324 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(324); + if (oldString324 instanceof Utf8) { + charSequence324 = (decoder).readString(((Utf8) oldString324)); + } else { + charSequence324 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(324, charSequence324); + } else { + throw new RuntimeException(("Illegal union index for 'F324': "+ unionIndex324)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex325 = (decoder.readIndex()); + if (unionIndex325 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(325, null); + } else { + if (unionIndex325 == 1) { + Utf8 charSequence325; + Object oldString325 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(325); + if (oldString325 instanceof Utf8) { + charSequence325 = (decoder).readString(((Utf8) oldString325)); + } else { + charSequence325 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(325, charSequence325); + } else { + throw new RuntimeException(("Illegal union index for 'F325': "+ unionIndex325)); + } + } + int unionIndex326 = (decoder.readIndex()); + if (unionIndex326 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(326, null); + } else { + if (unionIndex326 == 1) { + Utf8 charSequence326; + Object oldString326 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(326); + if (oldString326 instanceof Utf8) { + charSequence326 = (decoder).readString(((Utf8) oldString326)); + } else { + charSequence326 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(326, charSequence326); + } else { + throw new RuntimeException(("Illegal union index for 'F326': "+ unionIndex326)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex327 = (decoder.readIndex()); + if (unionIndex327 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(327, null); + } else { + if (unionIndex327 == 1) { + Utf8 charSequence327; + Object oldString327 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(327); + if (oldString327 instanceof Utf8) { + charSequence327 = (decoder).readString(((Utf8) oldString327)); + } else { + charSequence327 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(327, charSequence327); + } else { + throw new RuntimeException(("Illegal union index for 'F327': "+ unionIndex327)); + } + } + int unionIndex328 = (decoder.readIndex()); + if (unionIndex328 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(328, null); + } else { + if (unionIndex328 == 1) { + Utf8 charSequence328; + Object oldString328 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(328); + if (oldString328 instanceof Utf8) { + charSequence328 = (decoder).readString(((Utf8) oldString328)); + } else { + charSequence328 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(328, charSequence328); + } else { + throw new RuntimeException(("Illegal union index for 'F328': "+ unionIndex328)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex329 = (decoder.readIndex()); + if (unionIndex329 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(329, null); + } else { + if (unionIndex329 == 1) { + Utf8 charSequence329; + Object oldString329 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(329); + if (oldString329 instanceof Utf8) { + charSequence329 = (decoder).readString(((Utf8) oldString329)); + } else { + charSequence329 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(329, charSequence329); + } else { + throw new RuntimeException(("Illegal union index for 'F329': "+ unionIndex329)); + } + } + int unionIndex330 = (decoder.readIndex()); + if (unionIndex330 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(330, null); + } else { + if (unionIndex330 == 1) { + Utf8 charSequence330; + Object oldString330 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(330); + if (oldString330 instanceof Utf8) { + charSequence330 = (decoder).readString(((Utf8) oldString330)); + } else { + charSequence330 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(330, charSequence330); + } else { + throw new RuntimeException(("Illegal union index for 'F330': "+ unionIndex330)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex331 = (decoder.readIndex()); + if (unionIndex331 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(331, null); + } else { + if (unionIndex331 == 1) { + Utf8 charSequence331; + Object oldString331 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(331); + if (oldString331 instanceof Utf8) { + charSequence331 = (decoder).readString(((Utf8) oldString331)); + } else { + charSequence331 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(331, charSequence331); + } else { + throw new RuntimeException(("Illegal union index for 'F331': "+ unionIndex331)); + } + } + int unionIndex332 = (decoder.readIndex()); + if (unionIndex332 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(332, null); + } else { + if (unionIndex332 == 1) { + Utf8 charSequence332; + Object oldString332 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(332); + if (oldString332 instanceof Utf8) { + charSequence332 = (decoder).readString(((Utf8) oldString332)); + } else { + charSequence332 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(332, charSequence332); + } else { + throw new RuntimeException(("Illegal union index for 'F332': "+ unionIndex332)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex333 = (decoder.readIndex()); + if (unionIndex333 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(333, null); + } else { + if (unionIndex333 == 1) { + Utf8 charSequence333; + Object oldString333 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(333); + if (oldString333 instanceof Utf8) { + charSequence333 = (decoder).readString(((Utf8) oldString333)); + } else { + charSequence333 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(333, charSequence333); + } else { + throw new RuntimeException(("Illegal union index for 'F333': "+ unionIndex333)); + } + } + int unionIndex334 = (decoder.readIndex()); + if (unionIndex334 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(334, null); + } else { + if (unionIndex334 == 1) { + Utf8 charSequence334; + Object oldString334 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(334); + if (oldString334 instanceof Utf8) { + charSequence334 = (decoder).readString(((Utf8) oldString334)); + } else { + charSequence334 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(334, charSequence334); + } else { + throw new RuntimeException(("Illegal union index for 'F334': "+ unionIndex334)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex335 = (decoder.readIndex()); + if (unionIndex335 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(335, null); + } else { + if (unionIndex335 == 1) { + Utf8 charSequence335; + Object oldString335 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(335); + if (oldString335 instanceof Utf8) { + charSequence335 = (decoder).readString(((Utf8) oldString335)); + } else { + charSequence335 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(335, charSequence335); + } else { + throw new RuntimeException(("Illegal union index for 'F335': "+ unionIndex335)); + } + } + int unionIndex336 = (decoder.readIndex()); + if (unionIndex336 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(336, null); + } else { + if (unionIndex336 == 1) { + Utf8 charSequence336; + Object oldString336 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(336); + if (oldString336 instanceof Utf8) { + charSequence336 = (decoder).readString(((Utf8) oldString336)); + } else { + charSequence336 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(336, charSequence336); + } else { + throw new RuntimeException(("Illegal union index for 'F336': "+ unionIndex336)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex337 = (decoder.readIndex()); + if (unionIndex337 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(337, null); + } else { + if (unionIndex337 == 1) { + Utf8 charSequence337; + Object oldString337 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(337); + if (oldString337 instanceof Utf8) { + charSequence337 = (decoder).readString(((Utf8) oldString337)); + } else { + charSequence337 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(337, charSequence337); + } else { + throw new RuntimeException(("Illegal union index for 'F337': "+ unionIndex337)); + } + } + int unionIndex338 = (decoder.readIndex()); + if (unionIndex338 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(338, null); + } else { + if (unionIndex338 == 1) { + Utf8 charSequence338; + Object oldString338 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(338); + if (oldString338 instanceof Utf8) { + charSequence338 = (decoder).readString(((Utf8) oldString338)); + } else { + charSequence338 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(338, charSequence338); + } else { + throw new RuntimeException(("Illegal union index for 'F338': "+ unionIndex338)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex339 = (decoder.readIndex()); + if (unionIndex339 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(339, null); + } else { + if (unionIndex339 == 1) { + Utf8 charSequence339; + Object oldString339 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(339); + if (oldString339 instanceof Utf8) { + charSequence339 = (decoder).readString(((Utf8) oldString339)); + } else { + charSequence339 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(339, charSequence339); + } else { + throw new RuntimeException(("Illegal union index for 'F339': "+ unionIndex339)); + } + } + int unionIndex340 = (decoder.readIndex()); + if (unionIndex340 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(340, null); + } else { + if (unionIndex340 == 1) { + Utf8 charSequence340; + Object oldString340 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(340); + if (oldString340 instanceof Utf8) { + charSequence340 = (decoder).readString(((Utf8) oldString340)); + } else { + charSequence340 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(340, charSequence340); + } else { + throw new RuntimeException(("Illegal union index for 'F340': "+ unionIndex340)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex341 = (decoder.readIndex()); + if (unionIndex341 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(341, null); + } else { + if (unionIndex341 == 1) { + Utf8 charSequence341; + Object oldString341 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(341); + if (oldString341 instanceof Utf8) { + charSequence341 = (decoder).readString(((Utf8) oldString341)); + } else { + charSequence341 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(341, charSequence341); + } else { + throw new RuntimeException(("Illegal union index for 'F341': "+ unionIndex341)); + } + } + int unionIndex342 = (decoder.readIndex()); + if (unionIndex342 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(342, null); + } else { + if (unionIndex342 == 1) { + Utf8 charSequence342; + Object oldString342 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(342); + if (oldString342 instanceof Utf8) { + charSequence342 = (decoder).readString(((Utf8) oldString342)); + } else { + charSequence342 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(342, charSequence342); + } else { + throw new RuntimeException(("Illegal union index for 'F342': "+ unionIndex342)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex343 = (decoder.readIndex()); + if (unionIndex343 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(343, null); + } else { + if (unionIndex343 == 1) { + Utf8 charSequence343; + Object oldString343 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(343); + if (oldString343 instanceof Utf8) { + charSequence343 = (decoder).readString(((Utf8) oldString343)); + } else { + charSequence343 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(343, charSequence343); + } else { + throw new RuntimeException(("Illegal union index for 'F343': "+ unionIndex343)); + } + } + int unionIndex344 = (decoder.readIndex()); + if (unionIndex344 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(344, null); + } else { + if (unionIndex344 == 1) { + Utf8 charSequence344; + Object oldString344 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(344); + if (oldString344 instanceof Utf8) { + charSequence344 = (decoder).readString(((Utf8) oldString344)); + } else { + charSequence344 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(344, charSequence344); + } else { + throw new RuntimeException(("Illegal union index for 'F344': "+ unionIndex344)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex345 = (decoder.readIndex()); + if (unionIndex345 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(345, null); + } else { + if (unionIndex345 == 1) { + Utf8 charSequence345; + Object oldString345 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(345); + if (oldString345 instanceof Utf8) { + charSequence345 = (decoder).readString(((Utf8) oldString345)); + } else { + charSequence345 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(345, charSequence345); + } else { + throw new RuntimeException(("Illegal union index for 'F345': "+ unionIndex345)); + } + } + int unionIndex346 = (decoder.readIndex()); + if (unionIndex346 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(346, null); + } else { + if (unionIndex346 == 1) { + Utf8 charSequence346; + Object oldString346 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(346); + if (oldString346 instanceof Utf8) { + charSequence346 = (decoder).readString(((Utf8) oldString346)); + } else { + charSequence346 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(346, charSequence346); + } else { + throw new RuntimeException(("Illegal union index for 'F346': "+ unionIndex346)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex347 = (decoder.readIndex()); + if (unionIndex347 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(347, null); + } else { + if (unionIndex347 == 1) { + Utf8 charSequence347; + Object oldString347 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(347); + if (oldString347 instanceof Utf8) { + charSequence347 = (decoder).readString(((Utf8) oldString347)); + } else { + charSequence347 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(347, charSequence347); + } else { + throw new RuntimeException(("Illegal union index for 'F347': "+ unionIndex347)); + } + } + int unionIndex348 = (decoder.readIndex()); + if (unionIndex348 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(348, null); + } else { + if (unionIndex348 == 1) { + Utf8 charSequence348; + Object oldString348 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(348); + if (oldString348 instanceof Utf8) { + charSequence348 = (decoder).readString(((Utf8) oldString348)); + } else { + charSequence348 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(348, charSequence348); + } else { + throw new RuntimeException(("Illegal union index for 'F348': "+ unionIndex348)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex349 = (decoder.readIndex()); + if (unionIndex349 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(349, null); + } else { + if (unionIndex349 == 1) { + Utf8 charSequence349; + Object oldString349 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(349); + if (oldString349 instanceof Utf8) { + charSequence349 = (decoder).readString(((Utf8) oldString349)); + } else { + charSequence349 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(349, charSequence349); + } else { + throw new RuntimeException(("Illegal union index for 'F349': "+ unionIndex349)); + } + } + int unionIndex350 = (decoder.readIndex()); + if (unionIndex350 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(350, null); + } else { + if (unionIndex350 == 1) { + Utf8 charSequence350; + Object oldString350 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(350); + if (oldString350 instanceof Utf8) { + charSequence350 = (decoder).readString(((Utf8) oldString350)); + } else { + charSequence350 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(350, charSequence350); + } else { + throw new RuntimeException(("Illegal union index for 'F350': "+ unionIndex350)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex351 = (decoder.readIndex()); + if (unionIndex351 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(351, null); + } else { + if (unionIndex351 == 1) { + Utf8 charSequence351; + Object oldString351 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(351); + if (oldString351 instanceof Utf8) { + charSequence351 = (decoder).readString(((Utf8) oldString351)); + } else { + charSequence351 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(351, charSequence351); + } else { + throw new RuntimeException(("Illegal union index for 'F351': "+ unionIndex351)); + } + } + int unionIndex352 = (decoder.readIndex()); + if (unionIndex352 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(352, null); + } else { + if (unionIndex352 == 1) { + Utf8 charSequence352; + Object oldString352 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(352); + if (oldString352 instanceof Utf8) { + charSequence352 = (decoder).readString(((Utf8) oldString352)); + } else { + charSequence352 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(352, charSequence352); + } else { + throw new RuntimeException(("Illegal union index for 'F352': "+ unionIndex352)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex353 = (decoder.readIndex()); + if (unionIndex353 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(353, null); + } else { + if (unionIndex353 == 1) { + Utf8 charSequence353; + Object oldString353 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(353); + if (oldString353 instanceof Utf8) { + charSequence353 = (decoder).readString(((Utf8) oldString353)); + } else { + charSequence353 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(353, charSequence353); + } else { + throw new RuntimeException(("Illegal union index for 'F353': "+ unionIndex353)); + } + } + int unionIndex354 = (decoder.readIndex()); + if (unionIndex354 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(354, null); + } else { + if (unionIndex354 == 1) { + Utf8 charSequence354; + Object oldString354 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(354); + if (oldString354 instanceof Utf8) { + charSequence354 = (decoder).readString(((Utf8) oldString354)); + } else { + charSequence354 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(354, charSequence354); + } else { + throw new RuntimeException(("Illegal union index for 'F354': "+ unionIndex354)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex355 = (decoder.readIndex()); + if (unionIndex355 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(355, null); + } else { + if (unionIndex355 == 1) { + Utf8 charSequence355; + Object oldString355 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(355); + if (oldString355 instanceof Utf8) { + charSequence355 = (decoder).readString(((Utf8) oldString355)); + } else { + charSequence355 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(355, charSequence355); + } else { + throw new RuntimeException(("Illegal union index for 'F355': "+ unionIndex355)); + } + } + int unionIndex356 = (decoder.readIndex()); + if (unionIndex356 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(356, null); + } else { + if (unionIndex356 == 1) { + Utf8 charSequence356; + Object oldString356 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(356); + if (oldString356 instanceof Utf8) { + charSequence356 = (decoder).readString(((Utf8) oldString356)); + } else { + charSequence356 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(356, charSequence356); + } else { + throw new RuntimeException(("Illegal union index for 'F356': "+ unionIndex356)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex357 = (decoder.readIndex()); + if (unionIndex357 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(357, null); + } else { + if (unionIndex357 == 1) { + Utf8 charSequence357; + Object oldString357 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(357); + if (oldString357 instanceof Utf8) { + charSequence357 = (decoder).readString(((Utf8) oldString357)); + } else { + charSequence357 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(357, charSequence357); + } else { + throw new RuntimeException(("Illegal union index for 'F357': "+ unionIndex357)); + } + } + int unionIndex358 = (decoder.readIndex()); + if (unionIndex358 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(358, null); + } else { + if (unionIndex358 == 1) { + Utf8 charSequence358; + Object oldString358 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(358); + if (oldString358 instanceof Utf8) { + charSequence358 = (decoder).readString(((Utf8) oldString358)); + } else { + charSequence358 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(358, charSequence358); + } else { + throw new RuntimeException(("Illegal union index for 'F358': "+ unionIndex358)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex359 = (decoder.readIndex()); + if (unionIndex359 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(359, null); + } else { + if (unionIndex359 == 1) { + Utf8 charSequence359; + Object oldString359 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(359); + if (oldString359 instanceof Utf8) { + charSequence359 = (decoder).readString(((Utf8) oldString359)); + } else { + charSequence359 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(359, charSequence359); + } else { + throw new RuntimeException(("Illegal union index for 'F359': "+ unionIndex359)); + } + } + int unionIndex360 = (decoder.readIndex()); + if (unionIndex360 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(360, null); + } else { + if (unionIndex360 == 1) { + Utf8 charSequence360; + Object oldString360 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(360); + if (oldString360 instanceof Utf8) { + charSequence360 = (decoder).readString(((Utf8) oldString360)); + } else { + charSequence360 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(360, charSequence360); + } else { + throw new RuntimeException(("Illegal union index for 'F360': "+ unionIndex360)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex361 = (decoder.readIndex()); + if (unionIndex361 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(361, null); + } else { + if (unionIndex361 == 1) { + Utf8 charSequence361; + Object oldString361 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(361); + if (oldString361 instanceof Utf8) { + charSequence361 = (decoder).readString(((Utf8) oldString361)); + } else { + charSequence361 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(361, charSequence361); + } else { + throw new RuntimeException(("Illegal union index for 'F361': "+ unionIndex361)); + } + } + int unionIndex362 = (decoder.readIndex()); + if (unionIndex362 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(362, null); + } else { + if (unionIndex362 == 1) { + Utf8 charSequence362; + Object oldString362 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(362); + if (oldString362 instanceof Utf8) { + charSequence362 = (decoder).readString(((Utf8) oldString362)); + } else { + charSequence362 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(362, charSequence362); + } else { + throw new RuntimeException(("Illegal union index for 'F362': "+ unionIndex362)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex363 = (decoder.readIndex()); + if (unionIndex363 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(363, null); + } else { + if (unionIndex363 == 1) { + Utf8 charSequence363; + Object oldString363 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(363); + if (oldString363 instanceof Utf8) { + charSequence363 = (decoder).readString(((Utf8) oldString363)); + } else { + charSequence363 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(363, charSequence363); + } else { + throw new RuntimeException(("Illegal union index for 'F363': "+ unionIndex363)); + } + } + int unionIndex364 = (decoder.readIndex()); + if (unionIndex364 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(364, null); + } else { + if (unionIndex364 == 1) { + Utf8 charSequence364; + Object oldString364 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(364); + if (oldString364 instanceof Utf8) { + charSequence364 = (decoder).readString(((Utf8) oldString364)); + } else { + charSequence364 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(364, charSequence364); + } else { + throw new RuntimeException(("Illegal union index for 'F364': "+ unionIndex364)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex365 = (decoder.readIndex()); + if (unionIndex365 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(365, null); + } else { + if (unionIndex365 == 1) { + Utf8 charSequence365; + Object oldString365 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(365); + if (oldString365 instanceof Utf8) { + charSequence365 = (decoder).readString(((Utf8) oldString365)); + } else { + charSequence365 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(365, charSequence365); + } else { + throw new RuntimeException(("Illegal union index for 'F365': "+ unionIndex365)); + } + } + int unionIndex366 = (decoder.readIndex()); + if (unionIndex366 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(366, null); + } else { + if (unionIndex366 == 1) { + Utf8 charSequence366; + Object oldString366 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(366); + if (oldString366 instanceof Utf8) { + charSequence366 = (decoder).readString(((Utf8) oldString366)); + } else { + charSequence366 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(366, charSequence366); + } else { + throw new RuntimeException(("Illegal union index for 'F366': "+ unionIndex366)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex367 = (decoder.readIndex()); + if (unionIndex367 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(367, null); + } else { + if (unionIndex367 == 1) { + Utf8 charSequence367; + Object oldString367 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(367); + if (oldString367 instanceof Utf8) { + charSequence367 = (decoder).readString(((Utf8) oldString367)); + } else { + charSequence367 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(367, charSequence367); + } else { + throw new RuntimeException(("Illegal union index for 'F367': "+ unionIndex367)); + } + } + int unionIndex368 = (decoder.readIndex()); + if (unionIndex368 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(368, null); + } else { + if (unionIndex368 == 1) { + Utf8 charSequence368; + Object oldString368 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(368); + if (oldString368 instanceof Utf8) { + charSequence368 = (decoder).readString(((Utf8) oldString368)); + } else { + charSequence368 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(368, charSequence368); + } else { + throw new RuntimeException(("Illegal union index for 'F368': "+ unionIndex368)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex369 = (decoder.readIndex()); + if (unionIndex369 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(369, null); + } else { + if (unionIndex369 == 1) { + Utf8 charSequence369; + Object oldString369 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(369); + if (oldString369 instanceof Utf8) { + charSequence369 = (decoder).readString(((Utf8) oldString369)); + } else { + charSequence369 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(369, charSequence369); + } else { + throw new RuntimeException(("Illegal union index for 'F369': "+ unionIndex369)); + } + } + int unionIndex370 = (decoder.readIndex()); + if (unionIndex370 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(370, null); + } else { + if (unionIndex370 == 1) { + Utf8 charSequence370; + Object oldString370 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(370); + if (oldString370 instanceof Utf8) { + charSequence370 = (decoder).readString(((Utf8) oldString370)); + } else { + charSequence370 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(370, charSequence370); + } else { + throw new RuntimeException(("Illegal union index for 'F370': "+ unionIndex370)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex371 = (decoder.readIndex()); + if (unionIndex371 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(371, null); + } else { + if (unionIndex371 == 1) { + Utf8 charSequence371; + Object oldString371 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(371); + if (oldString371 instanceof Utf8) { + charSequence371 = (decoder).readString(((Utf8) oldString371)); + } else { + charSequence371 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(371, charSequence371); + } else { + throw new RuntimeException(("Illegal union index for 'F371': "+ unionIndex371)); + } + } + int unionIndex372 = (decoder.readIndex()); + if (unionIndex372 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(372, null); + } else { + if (unionIndex372 == 1) { + Utf8 charSequence372; + Object oldString372 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(372); + if (oldString372 instanceof Utf8) { + charSequence372 = (decoder).readString(((Utf8) oldString372)); + } else { + charSequence372 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(372, charSequence372); + } else { + throw new RuntimeException(("Illegal union index for 'F372': "+ unionIndex372)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex373 = (decoder.readIndex()); + if (unionIndex373 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(373, null); + } else { + if (unionIndex373 == 1) { + Utf8 charSequence373; + Object oldString373 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(373); + if (oldString373 instanceof Utf8) { + charSequence373 = (decoder).readString(((Utf8) oldString373)); + } else { + charSequence373 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(373, charSequence373); + } else { + throw new RuntimeException(("Illegal union index for 'F373': "+ unionIndex373)); + } + } + int unionIndex374 = (decoder.readIndex()); + if (unionIndex374 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(374, null); + } else { + if (unionIndex374 == 1) { + Utf8 charSequence374; + Object oldString374 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(374); + if (oldString374 instanceof Utf8) { + charSequence374 = (decoder).readString(((Utf8) oldString374)); + } else { + charSequence374 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(374, charSequence374); + } else { + throw new RuntimeException(("Illegal union index for 'F374': "+ unionIndex374)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex375 = (decoder.readIndex()); + if (unionIndex375 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(375, null); + } else { + if (unionIndex375 == 1) { + Utf8 charSequence375; + Object oldString375 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(375); + if (oldString375 instanceof Utf8) { + charSequence375 = (decoder).readString(((Utf8) oldString375)); + } else { + charSequence375 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(375, charSequence375); + } else { + throw new RuntimeException(("Illegal union index for 'F375': "+ unionIndex375)); + } + } + int unionIndex376 = (decoder.readIndex()); + if (unionIndex376 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(376, null); + } else { + if (unionIndex376 == 1) { + Utf8 charSequence376; + Object oldString376 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(376); + if (oldString376 instanceof Utf8) { + charSequence376 = (decoder).readString(((Utf8) oldString376)); + } else { + charSequence376 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(376, charSequence376); + } else { + throw new RuntimeException(("Illegal union index for 'F376': "+ unionIndex376)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex377 = (decoder.readIndex()); + if (unionIndex377 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(377, null); + } else { + if (unionIndex377 == 1) { + Utf8 charSequence377; + Object oldString377 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(377); + if (oldString377 instanceof Utf8) { + charSequence377 = (decoder).readString(((Utf8) oldString377)); + } else { + charSequence377 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(377, charSequence377); + } else { + throw new RuntimeException(("Illegal union index for 'F377': "+ unionIndex377)); + } + } + int unionIndex378 = (decoder.readIndex()); + if (unionIndex378 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(378, null); + } else { + if (unionIndex378 == 1) { + Utf8 charSequence378; + Object oldString378 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(378); + if (oldString378 instanceof Utf8) { + charSequence378 = (decoder).readString(((Utf8) oldString378)); + } else { + charSequence378 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(378, charSequence378); + } else { + throw new RuntimeException(("Illegal union index for 'F378': "+ unionIndex378)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex379 = (decoder.readIndex()); + if (unionIndex379 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(379, null); + } else { + if (unionIndex379 == 1) { + Utf8 charSequence379; + Object oldString379 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(379); + if (oldString379 instanceof Utf8) { + charSequence379 = (decoder).readString(((Utf8) oldString379)); + } else { + charSequence379 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(379, charSequence379); + } else { + throw new RuntimeException(("Illegal union index for 'F379': "+ unionIndex379)); + } + } + int unionIndex380 = (decoder.readIndex()); + if (unionIndex380 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(380, null); + } else { + if (unionIndex380 == 1) { + Utf8 charSequence380; + Object oldString380 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(380); + if (oldString380 instanceof Utf8) { + charSequence380 = (decoder).readString(((Utf8) oldString380)); + } else { + charSequence380 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(380, charSequence380); + } else { + throw new RuntimeException(("Illegal union index for 'F380': "+ unionIndex380)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex381 = (decoder.readIndex()); + if (unionIndex381 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(381, null); + } else { + if (unionIndex381 == 1) { + Utf8 charSequence381; + Object oldString381 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(381); + if (oldString381 instanceof Utf8) { + charSequence381 = (decoder).readString(((Utf8) oldString381)); + } else { + charSequence381 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(381, charSequence381); + } else { + throw new RuntimeException(("Illegal union index for 'F381': "+ unionIndex381)); + } + } + int unionIndex382 = (decoder.readIndex()); + if (unionIndex382 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(382, null); + } else { + if (unionIndex382 == 1) { + Utf8 charSequence382; + Object oldString382 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(382); + if (oldString382 instanceof Utf8) { + charSequence382 = (decoder).readString(((Utf8) oldString382)); + } else { + charSequence382 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(382, charSequence382); + } else { + throw new RuntimeException(("Illegal union index for 'F382': "+ unionIndex382)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex383 = (decoder.readIndex()); + if (unionIndex383 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(383, null); + } else { + if (unionIndex383 == 1) { + Utf8 charSequence383; + Object oldString383 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(383); + if (oldString383 instanceof Utf8) { + charSequence383 = (decoder).readString(((Utf8) oldString383)); + } else { + charSequence383 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(383, charSequence383); + } else { + throw new RuntimeException(("Illegal union index for 'F383': "+ unionIndex383)); + } + } + int unionIndex384 = (decoder.readIndex()); + if (unionIndex384 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(384, null); + } else { + if (unionIndex384 == 1) { + Utf8 charSequence384; + Object oldString384 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(384); + if (oldString384 instanceof Utf8) { + charSequence384 = (decoder).readString(((Utf8) oldString384)); + } else { + charSequence384 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(384, charSequence384); + } else { + throw new RuntimeException(("Illegal union index for 'F384': "+ unionIndex384)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex385 = (decoder.readIndex()); + if (unionIndex385 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(385, null); + } else { + if (unionIndex385 == 1) { + Utf8 charSequence385; + Object oldString385 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(385); + if (oldString385 instanceof Utf8) { + charSequence385 = (decoder).readString(((Utf8) oldString385)); + } else { + charSequence385 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(385, charSequence385); + } else { + throw new RuntimeException(("Illegal union index for 'F385': "+ unionIndex385)); + } + } + int unionIndex386 = (decoder.readIndex()); + if (unionIndex386 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(386, null); + } else { + if (unionIndex386 == 1) { + Utf8 charSequence386; + Object oldString386 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(386); + if (oldString386 instanceof Utf8) { + charSequence386 = (decoder).readString(((Utf8) oldString386)); + } else { + charSequence386 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(386, charSequence386); + } else { + throw new RuntimeException(("Illegal union index for 'F386': "+ unionIndex386)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex387 = (decoder.readIndex()); + if (unionIndex387 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(387, null); + } else { + if (unionIndex387 == 1) { + Utf8 charSequence387; + Object oldString387 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(387); + if (oldString387 instanceof Utf8) { + charSequence387 = (decoder).readString(((Utf8) oldString387)); + } else { + charSequence387 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(387, charSequence387); + } else { + throw new RuntimeException(("Illegal union index for 'F387': "+ unionIndex387)); + } + } + int unionIndex388 = (decoder.readIndex()); + if (unionIndex388 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(388, null); + } else { + if (unionIndex388 == 1) { + Utf8 charSequence388; + Object oldString388 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(388); + if (oldString388 instanceof Utf8) { + charSequence388 = (decoder).readString(((Utf8) oldString388)); + } else { + charSequence388 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(388, charSequence388); + } else { + throw new RuntimeException(("Illegal union index for 'F388': "+ unionIndex388)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex389 = (decoder.readIndex()); + if (unionIndex389 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(389, null); + } else { + if (unionIndex389 == 1) { + Utf8 charSequence389; + Object oldString389 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(389); + if (oldString389 instanceof Utf8) { + charSequence389 = (decoder).readString(((Utf8) oldString389)); + } else { + charSequence389 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(389, charSequence389); + } else { + throw new RuntimeException(("Illegal union index for 'F389': "+ unionIndex389)); + } + } + int unionIndex390 = (decoder.readIndex()); + if (unionIndex390 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(390, null); + } else { + if (unionIndex390 == 1) { + Utf8 charSequence390; + Object oldString390 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(390); + if (oldString390 instanceof Utf8) { + charSequence390 = (decoder).readString(((Utf8) oldString390)); + } else { + charSequence390 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(390, charSequence390); + } else { + throw new RuntimeException(("Illegal union index for 'F390': "+ unionIndex390)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex391 = (decoder.readIndex()); + if (unionIndex391 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(391, null); + } else { + if (unionIndex391 == 1) { + Utf8 charSequence391; + Object oldString391 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(391); + if (oldString391 instanceof Utf8) { + charSequence391 = (decoder).readString(((Utf8) oldString391)); + } else { + charSequence391 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(391, charSequence391); + } else { + throw new RuntimeException(("Illegal union index for 'F391': "+ unionIndex391)); + } + } + int unionIndex392 = (decoder.readIndex()); + if (unionIndex392 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(392, null); + } else { + if (unionIndex392 == 1) { + Utf8 charSequence392; + Object oldString392 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(392); + if (oldString392 instanceof Utf8) { + charSequence392 = (decoder).readString(((Utf8) oldString392)); + } else { + charSequence392 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(392, charSequence392); + } else { + throw new RuntimeException(("Illegal union index for 'F392': "+ unionIndex392)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex393 = (decoder.readIndex()); + if (unionIndex393 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(393, null); + } else { + if (unionIndex393 == 1) { + Utf8 charSequence393; + Object oldString393 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(393); + if (oldString393 instanceof Utf8) { + charSequence393 = (decoder).readString(((Utf8) oldString393)); + } else { + charSequence393 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(393, charSequence393); + } else { + throw new RuntimeException(("Illegal union index for 'F393': "+ unionIndex393)); + } + } + int unionIndex394 = (decoder.readIndex()); + if (unionIndex394 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(394, null); + } else { + if (unionIndex394 == 1) { + Utf8 charSequence394; + Object oldString394 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(394); + if (oldString394 instanceof Utf8) { + charSequence394 = (decoder).readString(((Utf8) oldString394)); + } else { + charSequence394 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(394, charSequence394); + } else { + throw new RuntimeException(("Illegal union index for 'F394': "+ unionIndex394)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex395 = (decoder.readIndex()); + if (unionIndex395 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(395, null); + } else { + if (unionIndex395 == 1) { + Utf8 charSequence395; + Object oldString395 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(395); + if (oldString395 instanceof Utf8) { + charSequence395 = (decoder).readString(((Utf8) oldString395)); + } else { + charSequence395 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(395, charSequence395); + } else { + throw new RuntimeException(("Illegal union index for 'F395': "+ unionIndex395)); + } + } + int unionIndex396 = (decoder.readIndex()); + if (unionIndex396 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(396, null); + } else { + if (unionIndex396 == 1) { + Utf8 charSequence396; + Object oldString396 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(396); + if (oldString396 instanceof Utf8) { + charSequence396 = (decoder).readString(((Utf8) oldString396)); + } else { + charSequence396 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(396, charSequence396); + } else { + throw new RuntimeException(("Illegal union index for 'F396': "+ unionIndex396)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex397 = (decoder.readIndex()); + if (unionIndex397 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(397, null); + } else { + if (unionIndex397 == 1) { + Utf8 charSequence397; + Object oldString397 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(397); + if (oldString397 instanceof Utf8) { + charSequence397 = (decoder).readString(((Utf8) oldString397)); + } else { + charSequence397 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(397, charSequence397); + } else { + throw new RuntimeException(("Illegal union index for 'F397': "+ unionIndex397)); + } + } + int unionIndex398 = (decoder.readIndex()); + if (unionIndex398 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(398, null); + } else { + if (unionIndex398 == 1) { + Utf8 charSequence398; + Object oldString398 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(398); + if (oldString398 instanceof Utf8) { + charSequence398 = (decoder).readString(((Utf8) oldString398)); + } else { + charSequence398 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(398, charSequence398); + } else { + throw new RuntimeException(("Illegal union index for 'F398': "+ unionIndex398)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex399 = (decoder.readIndex()); + if (unionIndex399 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(399, null); + } else { + if (unionIndex399 == 1) { + Utf8 charSequence399; + Object oldString399 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(399); + if (oldString399 instanceof Utf8) { + charSequence399 = (decoder).readString(((Utf8) oldString399)); + } else { + charSequence399 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(399, charSequence399); + } else { + throw new RuntimeException(("Illegal union index for 'F399': "+ unionIndex399)); + } + } + int unionIndex400 = (decoder.readIndex()); + if (unionIndex400 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(400, null); + } else { + if (unionIndex400 == 1) { + Utf8 charSequence400; + Object oldString400 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(400); + if (oldString400 instanceof Utf8) { + charSequence400 = (decoder).readString(((Utf8) oldString400)); + } else { + charSequence400 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(400, charSequence400); + } else { + throw new RuntimeException(("Illegal union index for 'F400': "+ unionIndex400)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex401 = (decoder.readIndex()); + if (unionIndex401 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(401, null); + } else { + if (unionIndex401 == 1) { + Utf8 charSequence401; + Object oldString401 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(401); + if (oldString401 instanceof Utf8) { + charSequence401 = (decoder).readString(((Utf8) oldString401)); + } else { + charSequence401 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(401, charSequence401); + } else { + throw new RuntimeException(("Illegal union index for 'F401': "+ unionIndex401)); + } + } + int unionIndex402 = (decoder.readIndex()); + if (unionIndex402 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(402, null); + } else { + if (unionIndex402 == 1) { + Utf8 charSequence402; + Object oldString402 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(402); + if (oldString402 instanceof Utf8) { + charSequence402 = (decoder).readString(((Utf8) oldString402)); + } else { + charSequence402 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(402, charSequence402); + } else { + throw new RuntimeException(("Illegal union index for 'F402': "+ unionIndex402)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex403 = (decoder.readIndex()); + if (unionIndex403 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(403, null); + } else { + if (unionIndex403 == 1) { + Utf8 charSequence403; + Object oldString403 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(403); + if (oldString403 instanceof Utf8) { + charSequence403 = (decoder).readString(((Utf8) oldString403)); + } else { + charSequence403 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(403, charSequence403); + } else { + throw new RuntimeException(("Illegal union index for 'F403': "+ unionIndex403)); + } + } + int unionIndex404 = (decoder.readIndex()); + if (unionIndex404 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(404, null); + } else { + if (unionIndex404 == 1) { + Utf8 charSequence404; + Object oldString404 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(404); + if (oldString404 instanceof Utf8) { + charSequence404 = (decoder).readString(((Utf8) oldString404)); + } else { + charSequence404 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(404, charSequence404); + } else { + throw new RuntimeException(("Illegal union index for 'F404': "+ unionIndex404)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex405 = (decoder.readIndex()); + if (unionIndex405 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(405, null); + } else { + if (unionIndex405 == 1) { + Utf8 charSequence405; + Object oldString405 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(405); + if (oldString405 instanceof Utf8) { + charSequence405 = (decoder).readString(((Utf8) oldString405)); + } else { + charSequence405 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(405, charSequence405); + } else { + throw new RuntimeException(("Illegal union index for 'F405': "+ unionIndex405)); + } + } + int unionIndex406 = (decoder.readIndex()); + if (unionIndex406 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(406, null); + } else { + if (unionIndex406 == 1) { + Utf8 charSequence406; + Object oldString406 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(406); + if (oldString406 instanceof Utf8) { + charSequence406 = (decoder).readString(((Utf8) oldString406)); + } else { + charSequence406 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(406, charSequence406); + } else { + throw new RuntimeException(("Illegal union index for 'F406': "+ unionIndex406)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex407 = (decoder.readIndex()); + if (unionIndex407 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(407, null); + } else { + if (unionIndex407 == 1) { + Utf8 charSequence407; + Object oldString407 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(407); + if (oldString407 instanceof Utf8) { + charSequence407 = (decoder).readString(((Utf8) oldString407)); + } else { + charSequence407 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(407, charSequence407); + } else { + throw new RuntimeException(("Illegal union index for 'F407': "+ unionIndex407)); + } + } + int unionIndex408 = (decoder.readIndex()); + if (unionIndex408 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(408, null); + } else { + if (unionIndex408 == 1) { + Utf8 charSequence408; + Object oldString408 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(408); + if (oldString408 instanceof Utf8) { + charSequence408 = (decoder).readString(((Utf8) oldString408)); + } else { + charSequence408 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(408, charSequence408); + } else { + throw new RuntimeException(("Illegal union index for 'F408': "+ unionIndex408)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex409 = (decoder.readIndex()); + if (unionIndex409 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(409, null); + } else { + if (unionIndex409 == 1) { + Utf8 charSequence409; + Object oldString409 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(409); + if (oldString409 instanceof Utf8) { + charSequence409 = (decoder).readString(((Utf8) oldString409)); + } else { + charSequence409 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(409, charSequence409); + } else { + throw new RuntimeException(("Illegal union index for 'F409': "+ unionIndex409)); + } + } + int unionIndex410 = (decoder.readIndex()); + if (unionIndex410 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(410, null); + } else { + if (unionIndex410 == 1) { + Utf8 charSequence410; + Object oldString410 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(410); + if (oldString410 instanceof Utf8) { + charSequence410 = (decoder).readString(((Utf8) oldString410)); + } else { + charSequence410 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(410, charSequence410); + } else { + throw new RuntimeException(("Illegal union index for 'F410': "+ unionIndex410)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex411 = (decoder.readIndex()); + if (unionIndex411 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(411, null); + } else { + if (unionIndex411 == 1) { + Utf8 charSequence411; + Object oldString411 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(411); + if (oldString411 instanceof Utf8) { + charSequence411 = (decoder).readString(((Utf8) oldString411)); + } else { + charSequence411 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(411, charSequence411); + } else { + throw new RuntimeException(("Illegal union index for 'F411': "+ unionIndex411)); + } + } + int unionIndex412 = (decoder.readIndex()); + if (unionIndex412 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(412, null); + } else { + if (unionIndex412 == 1) { + Utf8 charSequence412; + Object oldString412 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(412); + if (oldString412 instanceof Utf8) { + charSequence412 = (decoder).readString(((Utf8) oldString412)); + } else { + charSequence412 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(412, charSequence412); + } else { + throw new RuntimeException(("Illegal union index for 'F412': "+ unionIndex412)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex413 = (decoder.readIndex()); + if (unionIndex413 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(413, null); + } else { + if (unionIndex413 == 1) { + Utf8 charSequence413; + Object oldString413 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(413); + if (oldString413 instanceof Utf8) { + charSequence413 = (decoder).readString(((Utf8) oldString413)); + } else { + charSequence413 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(413, charSequence413); + } else { + throw new RuntimeException(("Illegal union index for 'F413': "+ unionIndex413)); + } + } + int unionIndex414 = (decoder.readIndex()); + if (unionIndex414 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(414, null); + } else { + if (unionIndex414 == 1) { + Utf8 charSequence414; + Object oldString414 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(414); + if (oldString414 instanceof Utf8) { + charSequence414 = (decoder).readString(((Utf8) oldString414)); + } else { + charSequence414 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(414, charSequence414); + } else { + throw new RuntimeException(("Illegal union index for 'F414': "+ unionIndex414)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex415 = (decoder.readIndex()); + if (unionIndex415 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(415, null); + } else { + if (unionIndex415 == 1) { + Utf8 charSequence415; + Object oldString415 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(415); + if (oldString415 instanceof Utf8) { + charSequence415 = (decoder).readString(((Utf8) oldString415)); + } else { + charSequence415 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(415, charSequence415); + } else { + throw new RuntimeException(("Illegal union index for 'F415': "+ unionIndex415)); + } + } + int unionIndex416 = (decoder.readIndex()); + if (unionIndex416 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(416, null); + } else { + if (unionIndex416 == 1) { + Utf8 charSequence416; + Object oldString416 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(416); + if (oldString416 instanceof Utf8) { + charSequence416 = (decoder).readString(((Utf8) oldString416)); + } else { + charSequence416 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(416, charSequence416); + } else { + throw new RuntimeException(("Illegal union index for 'F416': "+ unionIndex416)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex417 = (decoder.readIndex()); + if (unionIndex417 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(417, null); + } else { + if (unionIndex417 == 1) { + Utf8 charSequence417; + Object oldString417 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(417); + if (oldString417 instanceof Utf8) { + charSequence417 = (decoder).readString(((Utf8) oldString417)); + } else { + charSequence417 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(417, charSequence417); + } else { + throw new RuntimeException(("Illegal union index for 'F417': "+ unionIndex417)); + } + } + int unionIndex418 = (decoder.readIndex()); + if (unionIndex418 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(418, null); + } else { + if (unionIndex418 == 1) { + Utf8 charSequence418; + Object oldString418 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(418); + if (oldString418 instanceof Utf8) { + charSequence418 = (decoder).readString(((Utf8) oldString418)); + } else { + charSequence418 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(418, charSequence418); + } else { + throw new RuntimeException(("Illegal union index for 'F418': "+ unionIndex418)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex419 = (decoder.readIndex()); + if (unionIndex419 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(419, null); + } else { + if (unionIndex419 == 1) { + Utf8 charSequence419; + Object oldString419 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(419); + if (oldString419 instanceof Utf8) { + charSequence419 = (decoder).readString(((Utf8) oldString419)); + } else { + charSequence419 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(419, charSequence419); + } else { + throw new RuntimeException(("Illegal union index for 'F419': "+ unionIndex419)); + } + } + int unionIndex420 = (decoder.readIndex()); + if (unionIndex420 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(420, null); + } else { + if (unionIndex420 == 1) { + Utf8 charSequence420; + Object oldString420 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(420); + if (oldString420 instanceof Utf8) { + charSequence420 = (decoder).readString(((Utf8) oldString420)); + } else { + charSequence420 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(420, charSequence420); + } else { + throw new RuntimeException(("Illegal union index for 'F420': "+ unionIndex420)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex421 = (decoder.readIndex()); + if (unionIndex421 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(421, null); + } else { + if (unionIndex421 == 1) { + Utf8 charSequence421; + Object oldString421 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(421); + if (oldString421 instanceof Utf8) { + charSequence421 = (decoder).readString(((Utf8) oldString421)); + } else { + charSequence421 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(421, charSequence421); + } else { + throw new RuntimeException(("Illegal union index for 'F421': "+ unionIndex421)); + } + } + int unionIndex422 = (decoder.readIndex()); + if (unionIndex422 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(422, null); + } else { + if (unionIndex422 == 1) { + Utf8 charSequence422; + Object oldString422 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(422); + if (oldString422 instanceof Utf8) { + charSequence422 = (decoder).readString(((Utf8) oldString422)); + } else { + charSequence422 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(422, charSequence422); + } else { + throw new RuntimeException(("Illegal union index for 'F422': "+ unionIndex422)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex423 = (decoder.readIndex()); + if (unionIndex423 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(423, null); + } else { + if (unionIndex423 == 1) { + Utf8 charSequence423; + Object oldString423 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(423); + if (oldString423 instanceof Utf8) { + charSequence423 = (decoder).readString(((Utf8) oldString423)); + } else { + charSequence423 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(423, charSequence423); + } else { + throw new RuntimeException(("Illegal union index for 'F423': "+ unionIndex423)); + } + } + int unionIndex424 = (decoder.readIndex()); + if (unionIndex424 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(424, null); + } else { + if (unionIndex424 == 1) { + Utf8 charSequence424; + Object oldString424 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(424); + if (oldString424 instanceof Utf8) { + charSequence424 = (decoder).readString(((Utf8) oldString424)); + } else { + charSequence424 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(424, charSequence424); + } else { + throw new RuntimeException(("Illegal union index for 'F424': "+ unionIndex424)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex425 = (decoder.readIndex()); + if (unionIndex425 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(425, null); + } else { + if (unionIndex425 == 1) { + Utf8 charSequence425; + Object oldString425 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(425); + if (oldString425 instanceof Utf8) { + charSequence425 = (decoder).readString(((Utf8) oldString425)); + } else { + charSequence425 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(425, charSequence425); + } else { + throw new RuntimeException(("Illegal union index for 'F425': "+ unionIndex425)); + } + } + int unionIndex426 = (decoder.readIndex()); + if (unionIndex426 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(426, null); + } else { + if (unionIndex426 == 1) { + Utf8 charSequence426; + Object oldString426 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(426); + if (oldString426 instanceof Utf8) { + charSequence426 = (decoder).readString(((Utf8) oldString426)); + } else { + charSequence426 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(426, charSequence426); + } else { + throw new RuntimeException(("Illegal union index for 'F426': "+ unionIndex426)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex427 = (decoder.readIndex()); + if (unionIndex427 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(427, null); + } else { + if (unionIndex427 == 1) { + Utf8 charSequence427; + Object oldString427 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(427); + if (oldString427 instanceof Utf8) { + charSequence427 = (decoder).readString(((Utf8) oldString427)); + } else { + charSequence427 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(427, charSequence427); + } else { + throw new RuntimeException(("Illegal union index for 'F427': "+ unionIndex427)); + } + } + int unionIndex428 = (decoder.readIndex()); + if (unionIndex428 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(428, null); + } else { + if (unionIndex428 == 1) { + Utf8 charSequence428; + Object oldString428 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(428); + if (oldString428 instanceof Utf8) { + charSequence428 = (decoder).readString(((Utf8) oldString428)); + } else { + charSequence428 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(428, charSequence428); + } else { + throw new RuntimeException(("Illegal union index for 'F428': "+ unionIndex428)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex429 = (decoder.readIndex()); + if (unionIndex429 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(429, null); + } else { + if (unionIndex429 == 1) { + Utf8 charSequence429; + Object oldString429 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(429); + if (oldString429 instanceof Utf8) { + charSequence429 = (decoder).readString(((Utf8) oldString429)); + } else { + charSequence429 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(429, charSequence429); + } else { + throw new RuntimeException(("Illegal union index for 'F429': "+ unionIndex429)); + } + } + int unionIndex430 = (decoder.readIndex()); + if (unionIndex430 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(430, null); + } else { + if (unionIndex430 == 1) { + Utf8 charSequence430; + Object oldString430 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(430); + if (oldString430 instanceof Utf8) { + charSequence430 = (decoder).readString(((Utf8) oldString430)); + } else { + charSequence430 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(430, charSequence430); + } else { + throw new RuntimeException(("Illegal union index for 'F430': "+ unionIndex430)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex431 = (decoder.readIndex()); + if (unionIndex431 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(431, null); + } else { + if (unionIndex431 == 1) { + Utf8 charSequence431; + Object oldString431 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(431); + if (oldString431 instanceof Utf8) { + charSequence431 = (decoder).readString(((Utf8) oldString431)); + } else { + charSequence431 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(431, charSequence431); + } else { + throw new RuntimeException(("Illegal union index for 'F431': "+ unionIndex431)); + } + } + int unionIndex432 = (decoder.readIndex()); + if (unionIndex432 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(432, null); + } else { + if (unionIndex432 == 1) { + Utf8 charSequence432; + Object oldString432 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(432); + if (oldString432 instanceof Utf8) { + charSequence432 = (decoder).readString(((Utf8) oldString432)); + } else { + charSequence432 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(432, charSequence432); + } else { + throw new RuntimeException(("Illegal union index for 'F432': "+ unionIndex432)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex433 = (decoder.readIndex()); + if (unionIndex433 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(433, null); + } else { + if (unionIndex433 == 1) { + Utf8 charSequence433; + Object oldString433 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(433); + if (oldString433 instanceof Utf8) { + charSequence433 = (decoder).readString(((Utf8) oldString433)); + } else { + charSequence433 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(433, charSequence433); + } else { + throw new RuntimeException(("Illegal union index for 'F433': "+ unionIndex433)); + } + } + int unionIndex434 = (decoder.readIndex()); + if (unionIndex434 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(434, null); + } else { + if (unionIndex434 == 1) { + Utf8 charSequence434; + Object oldString434 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(434); + if (oldString434 instanceof Utf8) { + charSequence434 = (decoder).readString(((Utf8) oldString434)); + } else { + charSequence434 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(434, charSequence434); + } else { + throw new RuntimeException(("Illegal union index for 'F434': "+ unionIndex434)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex435 = (decoder.readIndex()); + if (unionIndex435 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(435, null); + } else { + if (unionIndex435 == 1) { + Utf8 charSequence435; + Object oldString435 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(435); + if (oldString435 instanceof Utf8) { + charSequence435 = (decoder).readString(((Utf8) oldString435)); + } else { + charSequence435 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(435, charSequence435); + } else { + throw new RuntimeException(("Illegal union index for 'F435': "+ unionIndex435)); + } + } + int unionIndex436 = (decoder.readIndex()); + if (unionIndex436 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(436, null); + } else { + if (unionIndex436 == 1) { + Utf8 charSequence436; + Object oldString436 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(436); + if (oldString436 instanceof Utf8) { + charSequence436 = (decoder).readString(((Utf8) oldString436)); + } else { + charSequence436 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(436, charSequence436); + } else { + throw new RuntimeException(("Illegal union index for 'F436': "+ unionIndex436)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex437 = (decoder.readIndex()); + if (unionIndex437 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(437, null); + } else { + if (unionIndex437 == 1) { + Utf8 charSequence437; + Object oldString437 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(437); + if (oldString437 instanceof Utf8) { + charSequence437 = (decoder).readString(((Utf8) oldString437)); + } else { + charSequence437 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(437, charSequence437); + } else { + throw new RuntimeException(("Illegal union index for 'F437': "+ unionIndex437)); + } + } + int unionIndex438 = (decoder.readIndex()); + if (unionIndex438 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(438, null); + } else { + if (unionIndex438 == 1) { + Utf8 charSequence438; + Object oldString438 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(438); + if (oldString438 instanceof Utf8) { + charSequence438 = (decoder).readString(((Utf8) oldString438)); + } else { + charSequence438 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(438, charSequence438); + } else { + throw new RuntimeException(("Illegal union index for 'F438': "+ unionIndex438)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex439 = (decoder.readIndex()); + if (unionIndex439 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(439, null); + } else { + if (unionIndex439 == 1) { + Utf8 charSequence439; + Object oldString439 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(439); + if (oldString439 instanceof Utf8) { + charSequence439 = (decoder).readString(((Utf8) oldString439)); + } else { + charSequence439 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(439, charSequence439); + } else { + throw new RuntimeException(("Illegal union index for 'F439': "+ unionIndex439)); + } + } + int unionIndex440 = (decoder.readIndex()); + if (unionIndex440 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(440, null); + } else { + if (unionIndex440 == 1) { + Utf8 charSequence440; + Object oldString440 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(440); + if (oldString440 instanceof Utf8) { + charSequence440 = (decoder).readString(((Utf8) oldString440)); + } else { + charSequence440 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(440, charSequence440); + } else { + throw new RuntimeException(("Illegal union index for 'F440': "+ unionIndex440)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex441 = (decoder.readIndex()); + if (unionIndex441 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(441, null); + } else { + if (unionIndex441 == 1) { + Utf8 charSequence441; + Object oldString441 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(441); + if (oldString441 instanceof Utf8) { + charSequence441 = (decoder).readString(((Utf8) oldString441)); + } else { + charSequence441 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(441, charSequence441); + } else { + throw new RuntimeException(("Illegal union index for 'F441': "+ unionIndex441)); + } + } + int unionIndex442 = (decoder.readIndex()); + if (unionIndex442 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(442, null); + } else { + if (unionIndex442 == 1) { + Utf8 charSequence442; + Object oldString442 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(442); + if (oldString442 instanceof Utf8) { + charSequence442 = (decoder).readString(((Utf8) oldString442)); + } else { + charSequence442 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(442, charSequence442); + } else { + throw new RuntimeException(("Illegal union index for 'F442': "+ unionIndex442)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex443 = (decoder.readIndex()); + if (unionIndex443 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(443, null); + } else { + if (unionIndex443 == 1) { + Utf8 charSequence443; + Object oldString443 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(443); + if (oldString443 instanceof Utf8) { + charSequence443 = (decoder).readString(((Utf8) oldString443)); + } else { + charSequence443 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(443, charSequence443); + } else { + throw new RuntimeException(("Illegal union index for 'F443': "+ unionIndex443)); + } + } + int unionIndex444 = (decoder.readIndex()); + if (unionIndex444 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(444, null); + } else { + if (unionIndex444 == 1) { + Utf8 charSequence444; + Object oldString444 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(444); + if (oldString444 instanceof Utf8) { + charSequence444 = (decoder).readString(((Utf8) oldString444)); + } else { + charSequence444 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(444, charSequence444); + } else { + throw new RuntimeException(("Illegal union index for 'F444': "+ unionIndex444)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex445 = (decoder.readIndex()); + if (unionIndex445 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(445, null); + } else { + if (unionIndex445 == 1) { + Utf8 charSequence445; + Object oldString445 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(445); + if (oldString445 instanceof Utf8) { + charSequence445 = (decoder).readString(((Utf8) oldString445)); + } else { + charSequence445 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(445, charSequence445); + } else { + throw new RuntimeException(("Illegal union index for 'F445': "+ unionIndex445)); + } + } + int unionIndex446 = (decoder.readIndex()); + if (unionIndex446 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(446, null); + } else { + if (unionIndex446 == 1) { + Utf8 charSequence446; + Object oldString446 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(446); + if (oldString446 instanceof Utf8) { + charSequence446 = (decoder).readString(((Utf8) oldString446)); + } else { + charSequence446 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(446, charSequence446); + } else { + throw new RuntimeException(("Illegal union index for 'F446': "+ unionIndex446)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex447 = (decoder.readIndex()); + if (unionIndex447 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(447, null); + } else { + if (unionIndex447 == 1) { + Utf8 charSequence447; + Object oldString447 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(447); + if (oldString447 instanceof Utf8) { + charSequence447 = (decoder).readString(((Utf8) oldString447)); + } else { + charSequence447 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(447, charSequence447); + } else { + throw new RuntimeException(("Illegal union index for 'F447': "+ unionIndex447)); + } + } + int unionIndex448 = (decoder.readIndex()); + if (unionIndex448 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(448, null); + } else { + if (unionIndex448 == 1) { + Utf8 charSequence448; + Object oldString448 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(448); + if (oldString448 instanceof Utf8) { + charSequence448 = (decoder).readString(((Utf8) oldString448)); + } else { + charSequence448 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(448, charSequence448); + } else { + throw new RuntimeException(("Illegal union index for 'F448': "+ unionIndex448)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex449 = (decoder.readIndex()); + if (unionIndex449 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(449, null); + } else { + if (unionIndex449 == 1) { + Utf8 charSequence449; + Object oldString449 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(449); + if (oldString449 instanceof Utf8) { + charSequence449 = (decoder).readString(((Utf8) oldString449)); + } else { + charSequence449 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(449, charSequence449); + } else { + throw new RuntimeException(("Illegal union index for 'F449': "+ unionIndex449)); + } + } + int unionIndex450 = (decoder.readIndex()); + if (unionIndex450 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(450, null); + } else { + if (unionIndex450 == 1) { + Utf8 charSequence450; + Object oldString450 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(450); + if (oldString450 instanceof Utf8) { + charSequence450 = (decoder).readString(((Utf8) oldString450)); + } else { + charSequence450 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(450, charSequence450); + } else { + throw new RuntimeException(("Illegal union index for 'F450': "+ unionIndex450)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex451 = (decoder.readIndex()); + if (unionIndex451 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(451, null); + } else { + if (unionIndex451 == 1) { + Utf8 charSequence451; + Object oldString451 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(451); + if (oldString451 instanceof Utf8) { + charSequence451 = (decoder).readString(((Utf8) oldString451)); + } else { + charSequence451 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(451, charSequence451); + } else { + throw new RuntimeException(("Illegal union index for 'F451': "+ unionIndex451)); + } + } + int unionIndex452 = (decoder.readIndex()); + if (unionIndex452 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(452, null); + } else { + if (unionIndex452 == 1) { + Utf8 charSequence452; + Object oldString452 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(452); + if (oldString452 instanceof Utf8) { + charSequence452 = (decoder).readString(((Utf8) oldString452)); + } else { + charSequence452 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(452, charSequence452); + } else { + throw new RuntimeException(("Illegal union index for 'F452': "+ unionIndex452)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex453 = (decoder.readIndex()); + if (unionIndex453 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(453, null); + } else { + if (unionIndex453 == 1) { + Utf8 charSequence453; + Object oldString453 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(453); + if (oldString453 instanceof Utf8) { + charSequence453 = (decoder).readString(((Utf8) oldString453)); + } else { + charSequence453 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(453, charSequence453); + } else { + throw new RuntimeException(("Illegal union index for 'F453': "+ unionIndex453)); + } + } + int unionIndex454 = (decoder.readIndex()); + if (unionIndex454 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(454, null); + } else { + if (unionIndex454 == 1) { + Utf8 charSequence454; + Object oldString454 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(454); + if (oldString454 instanceof Utf8) { + charSequence454 = (decoder).readString(((Utf8) oldString454)); + } else { + charSequence454 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(454, charSequence454); + } else { + throw new RuntimeException(("Illegal union index for 'F454': "+ unionIndex454)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex455 = (decoder.readIndex()); + if (unionIndex455 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(455, null); + } else { + if (unionIndex455 == 1) { + Utf8 charSequence455; + Object oldString455 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(455); + if (oldString455 instanceof Utf8) { + charSequence455 = (decoder).readString(((Utf8) oldString455)); + } else { + charSequence455 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(455, charSequence455); + } else { + throw new RuntimeException(("Illegal union index for 'F455': "+ unionIndex455)); + } + } + int unionIndex456 = (decoder.readIndex()); + if (unionIndex456 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(456, null); + } else { + if (unionIndex456 == 1) { + Utf8 charSequence456; + Object oldString456 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(456); + if (oldString456 instanceof Utf8) { + charSequence456 = (decoder).readString(((Utf8) oldString456)); + } else { + charSequence456 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(456, charSequence456); + } else { + throw new RuntimeException(("Illegal union index for 'F456': "+ unionIndex456)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex457 = (decoder.readIndex()); + if (unionIndex457 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(457, null); + } else { + if (unionIndex457 == 1) { + Utf8 charSequence457; + Object oldString457 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(457); + if (oldString457 instanceof Utf8) { + charSequence457 = (decoder).readString(((Utf8) oldString457)); + } else { + charSequence457 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(457, charSequence457); + } else { + throw new RuntimeException(("Illegal union index for 'F457': "+ unionIndex457)); + } + } + int unionIndex458 = (decoder.readIndex()); + if (unionIndex458 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(458, null); + } else { + if (unionIndex458 == 1) { + Utf8 charSequence458; + Object oldString458 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(458); + if (oldString458 instanceof Utf8) { + charSequence458 = (decoder).readString(((Utf8) oldString458)); + } else { + charSequence458 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(458, charSequence458); + } else { + throw new RuntimeException(("Illegal union index for 'F458': "+ unionIndex458)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex459 = (decoder.readIndex()); + if (unionIndex459 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(459, null); + } else { + if (unionIndex459 == 1) { + Utf8 charSequence459; + Object oldString459 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(459); + if (oldString459 instanceof Utf8) { + charSequence459 = (decoder).readString(((Utf8) oldString459)); + } else { + charSequence459 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(459, charSequence459); + } else { + throw new RuntimeException(("Illegal union index for 'F459': "+ unionIndex459)); + } + } + int unionIndex460 = (decoder.readIndex()); + if (unionIndex460 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(460, null); + } else { + if (unionIndex460 == 1) { + Utf8 charSequence460; + Object oldString460 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(460); + if (oldString460 instanceof Utf8) { + charSequence460 = (decoder).readString(((Utf8) oldString460)); + } else { + charSequence460 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(460, charSequence460); + } else { + throw new RuntimeException(("Illegal union index for 'F460': "+ unionIndex460)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex461 = (decoder.readIndex()); + if (unionIndex461 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(461, null); + } else { + if (unionIndex461 == 1) { + Utf8 charSequence461; + Object oldString461 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(461); + if (oldString461 instanceof Utf8) { + charSequence461 = (decoder).readString(((Utf8) oldString461)); + } else { + charSequence461 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(461, charSequence461); + } else { + throw new RuntimeException(("Illegal union index for 'F461': "+ unionIndex461)); + } + } + int unionIndex462 = (decoder.readIndex()); + if (unionIndex462 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(462, null); + } else { + if (unionIndex462 == 1) { + Utf8 charSequence462; + Object oldString462 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(462); + if (oldString462 instanceof Utf8) { + charSequence462 = (decoder).readString(((Utf8) oldString462)); + } else { + charSequence462 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(462, charSequence462); + } else { + throw new RuntimeException(("Illegal union index for 'F462': "+ unionIndex462)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex463 = (decoder.readIndex()); + if (unionIndex463 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(463, null); + } else { + if (unionIndex463 == 1) { + Utf8 charSequence463; + Object oldString463 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(463); + if (oldString463 instanceof Utf8) { + charSequence463 = (decoder).readString(((Utf8) oldString463)); + } else { + charSequence463 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(463, charSequence463); + } else { + throw new RuntimeException(("Illegal union index for 'F463': "+ unionIndex463)); + } + } + int unionIndex464 = (decoder.readIndex()); + if (unionIndex464 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(464, null); + } else { + if (unionIndex464 == 1) { + Utf8 charSequence464; + Object oldString464 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(464); + if (oldString464 instanceof Utf8) { + charSequence464 = (decoder).readString(((Utf8) oldString464)); + } else { + charSequence464 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(464, charSequence464); + } else { + throw new RuntimeException(("Illegal union index for 'F464': "+ unionIndex464)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex465 = (decoder.readIndex()); + if (unionIndex465 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(465, null); + } else { + if (unionIndex465 == 1) { + Utf8 charSequence465; + Object oldString465 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(465); + if (oldString465 instanceof Utf8) { + charSequence465 = (decoder).readString(((Utf8) oldString465)); + } else { + charSequence465 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(465, charSequence465); + } else { + throw new RuntimeException(("Illegal union index for 'F465': "+ unionIndex465)); + } + } + int unionIndex466 = (decoder.readIndex()); + if (unionIndex466 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(466, null); + } else { + if (unionIndex466 == 1) { + Utf8 charSequence466; + Object oldString466 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(466); + if (oldString466 instanceof Utf8) { + charSequence466 = (decoder).readString(((Utf8) oldString466)); + } else { + charSequence466 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(466, charSequence466); + } else { + throw new RuntimeException(("Illegal union index for 'F466': "+ unionIndex466)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex467 = (decoder.readIndex()); + if (unionIndex467 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(467, null); + } else { + if (unionIndex467 == 1) { + Utf8 charSequence467; + Object oldString467 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(467); + if (oldString467 instanceof Utf8) { + charSequence467 = (decoder).readString(((Utf8) oldString467)); + } else { + charSequence467 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(467, charSequence467); + } else { + throw new RuntimeException(("Illegal union index for 'F467': "+ unionIndex467)); + } + } + int unionIndex468 = (decoder.readIndex()); + if (unionIndex468 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(468, null); + } else { + if (unionIndex468 == 1) { + Utf8 charSequence468; + Object oldString468 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(468); + if (oldString468 instanceof Utf8) { + charSequence468 = (decoder).readString(((Utf8) oldString468)); + } else { + charSequence468 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(468, charSequence468); + } else { + throw new RuntimeException(("Illegal union index for 'F468': "+ unionIndex468)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex469 = (decoder.readIndex()); + if (unionIndex469 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(469, null); + } else { + if (unionIndex469 == 1) { + Utf8 charSequence469; + Object oldString469 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(469); + if (oldString469 instanceof Utf8) { + charSequence469 = (decoder).readString(((Utf8) oldString469)); + } else { + charSequence469 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(469, charSequence469); + } else { + throw new RuntimeException(("Illegal union index for 'F469': "+ unionIndex469)); + } + } + int unionIndex470 = (decoder.readIndex()); + if (unionIndex470 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(470, null); + } else { + if (unionIndex470 == 1) { + Utf8 charSequence470; + Object oldString470 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(470); + if (oldString470 instanceof Utf8) { + charSequence470 = (decoder).readString(((Utf8) oldString470)); + } else { + charSequence470 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(470, charSequence470); + } else { + throw new RuntimeException(("Illegal union index for 'F470': "+ unionIndex470)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex471 = (decoder.readIndex()); + if (unionIndex471 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(471, null); + } else { + if (unionIndex471 == 1) { + Utf8 charSequence471; + Object oldString471 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(471); + if (oldString471 instanceof Utf8) { + charSequence471 = (decoder).readString(((Utf8) oldString471)); + } else { + charSequence471 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(471, charSequence471); + } else { + throw new RuntimeException(("Illegal union index for 'F471': "+ unionIndex471)); + } + } + int unionIndex472 = (decoder.readIndex()); + if (unionIndex472 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(472, null); + } else { + if (unionIndex472 == 1) { + Utf8 charSequence472; + Object oldString472 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(472); + if (oldString472 instanceof Utf8) { + charSequence472 = (decoder).readString(((Utf8) oldString472)); + } else { + charSequence472 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(472, charSequence472); + } else { + throw new RuntimeException(("Illegal union index for 'F472': "+ unionIndex472)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex473 = (decoder.readIndex()); + if (unionIndex473 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(473, null); + } else { + if (unionIndex473 == 1) { + Utf8 charSequence473; + Object oldString473 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(473); + if (oldString473 instanceof Utf8) { + charSequence473 = (decoder).readString(((Utf8) oldString473)); + } else { + charSequence473 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(473, charSequence473); + } else { + throw new RuntimeException(("Illegal union index for 'F473': "+ unionIndex473)); + } + } + int unionIndex474 = (decoder.readIndex()); + if (unionIndex474 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(474, null); + } else { + if (unionIndex474 == 1) { + Utf8 charSequence474; + Object oldString474 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(474); + if (oldString474 instanceof Utf8) { + charSequence474 = (decoder).readString(((Utf8) oldString474)); + } else { + charSequence474 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(474, charSequence474); + } else { + throw new RuntimeException(("Illegal union index for 'F474': "+ unionIndex474)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex475 = (decoder.readIndex()); + if (unionIndex475 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(475, null); + } else { + if (unionIndex475 == 1) { + Utf8 charSequence475; + Object oldString475 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(475); + if (oldString475 instanceof Utf8) { + charSequence475 = (decoder).readString(((Utf8) oldString475)); + } else { + charSequence475 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(475, charSequence475); + } else { + throw new RuntimeException(("Illegal union index for 'F475': "+ unionIndex475)); + } + } + int unionIndex476 = (decoder.readIndex()); + if (unionIndex476 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(476, null); + } else { + if (unionIndex476 == 1) { + Utf8 charSequence476; + Object oldString476 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(476); + if (oldString476 instanceof Utf8) { + charSequence476 = (decoder).readString(((Utf8) oldString476)); + } else { + charSequence476 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(476, charSequence476); + } else { + throw new RuntimeException(("Illegal union index for 'F476': "+ unionIndex476)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex477 = (decoder.readIndex()); + if (unionIndex477 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(477, null); + } else { + if (unionIndex477 == 1) { + Utf8 charSequence477; + Object oldString477 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(477); + if (oldString477 instanceof Utf8) { + charSequence477 = (decoder).readString(((Utf8) oldString477)); + } else { + charSequence477 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(477, charSequence477); + } else { + throw new RuntimeException(("Illegal union index for 'F477': "+ unionIndex477)); + } + } + int unionIndex478 = (decoder.readIndex()); + if (unionIndex478 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(478, null); + } else { + if (unionIndex478 == 1) { + Utf8 charSequence478; + Object oldString478 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(478); + if (oldString478 instanceof Utf8) { + charSequence478 = (decoder).readString(((Utf8) oldString478)); + } else { + charSequence478 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(478, charSequence478); + } else { + throw new RuntimeException(("Illegal union index for 'F478': "+ unionIndex478)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex479 = (decoder.readIndex()); + if (unionIndex479 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(479, null); + } else { + if (unionIndex479 == 1) { + Utf8 charSequence479; + Object oldString479 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(479); + if (oldString479 instanceof Utf8) { + charSequence479 = (decoder).readString(((Utf8) oldString479)); + } else { + charSequence479 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(479, charSequence479); + } else { + throw new RuntimeException(("Illegal union index for 'F479': "+ unionIndex479)); + } + } + int unionIndex480 = (decoder.readIndex()); + if (unionIndex480 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(480, null); + } else { + if (unionIndex480 == 1) { + Utf8 charSequence480; + Object oldString480 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(480); + if (oldString480 instanceof Utf8) { + charSequence480 = (decoder).readString(((Utf8) oldString480)); + } else { + charSequence480 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(480, charSequence480); + } else { + throw new RuntimeException(("Illegal union index for 'F480': "+ unionIndex480)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex481 = (decoder.readIndex()); + if (unionIndex481 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(481, null); + } else { + if (unionIndex481 == 1) { + Utf8 charSequence481; + Object oldString481 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(481); + if (oldString481 instanceof Utf8) { + charSequence481 = (decoder).readString(((Utf8) oldString481)); + } else { + charSequence481 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(481, charSequence481); + } else { + throw new RuntimeException(("Illegal union index for 'F481': "+ unionIndex481)); + } + } + int unionIndex482 = (decoder.readIndex()); + if (unionIndex482 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(482, null); + } else { + if (unionIndex482 == 1) { + Utf8 charSequence482; + Object oldString482 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(482); + if (oldString482 instanceof Utf8) { + charSequence482 = (decoder).readString(((Utf8) oldString482)); + } else { + charSequence482 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(482, charSequence482); + } else { + throw new RuntimeException(("Illegal union index for 'F482': "+ unionIndex482)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex483 = (decoder.readIndex()); + if (unionIndex483 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(483, null); + } else { + if (unionIndex483 == 1) { + Utf8 charSequence483; + Object oldString483 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(483); + if (oldString483 instanceof Utf8) { + charSequence483 = (decoder).readString(((Utf8) oldString483)); + } else { + charSequence483 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(483, charSequence483); + } else { + throw new RuntimeException(("Illegal union index for 'F483': "+ unionIndex483)); + } + } + int unionIndex484 = (decoder.readIndex()); + if (unionIndex484 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(484, null); + } else { + if (unionIndex484 == 1) { + Utf8 charSequence484; + Object oldString484 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(484); + if (oldString484 instanceof Utf8) { + charSequence484 = (decoder).readString(((Utf8) oldString484)); + } else { + charSequence484 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(484, charSequence484); + } else { + throw new RuntimeException(("Illegal union index for 'F484': "+ unionIndex484)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex485 = (decoder.readIndex()); + if (unionIndex485 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(485, null); + } else { + if (unionIndex485 == 1) { + Utf8 charSequence485; + Object oldString485 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(485); + if (oldString485 instanceof Utf8) { + charSequence485 = (decoder).readString(((Utf8) oldString485)); + } else { + charSequence485 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(485, charSequence485); + } else { + throw new RuntimeException(("Illegal union index for 'F485': "+ unionIndex485)); + } + } + int unionIndex486 = (decoder.readIndex()); + if (unionIndex486 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(486, null); + } else { + if (unionIndex486 == 1) { + Utf8 charSequence486; + Object oldString486 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(486); + if (oldString486 instanceof Utf8) { + charSequence486 = (decoder).readString(((Utf8) oldString486)); + } else { + charSequence486 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(486, charSequence486); + } else { + throw new RuntimeException(("Illegal union index for 'F486': "+ unionIndex486)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex487 = (decoder.readIndex()); + if (unionIndex487 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(487, null); + } else { + if (unionIndex487 == 1) { + Utf8 charSequence487; + Object oldString487 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(487); + if (oldString487 instanceof Utf8) { + charSequence487 = (decoder).readString(((Utf8) oldString487)); + } else { + charSequence487 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(487, charSequence487); + } else { + throw new RuntimeException(("Illegal union index for 'F487': "+ unionIndex487)); + } + } + int unionIndex488 = (decoder.readIndex()); + if (unionIndex488 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(488, null); + } else { + if (unionIndex488 == 1) { + Utf8 charSequence488; + Object oldString488 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(488); + if (oldString488 instanceof Utf8) { + charSequence488 = (decoder).readString(((Utf8) oldString488)); + } else { + charSequence488 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(488, charSequence488); + } else { + throw new RuntimeException(("Illegal union index for 'F488': "+ unionIndex488)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex489 = (decoder.readIndex()); + if (unionIndex489 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(489, null); + } else { + if (unionIndex489 == 1) { + Utf8 charSequence489; + Object oldString489 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(489); + if (oldString489 instanceof Utf8) { + charSequence489 = (decoder).readString(((Utf8) oldString489)); + } else { + charSequence489 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(489, charSequence489); + } else { + throw new RuntimeException(("Illegal union index for 'F489': "+ unionIndex489)); + } + } + int unionIndex490 = (decoder.readIndex()); + if (unionIndex490 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(490, null); + } else { + if (unionIndex490 == 1) { + Utf8 charSequence490; + Object oldString490 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(490); + if (oldString490 instanceof Utf8) { + charSequence490 = (decoder).readString(((Utf8) oldString490)); + } else { + charSequence490 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(490, charSequence490); + } else { + throw new RuntimeException(("Illegal union index for 'F490': "+ unionIndex490)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex491 = (decoder.readIndex()); + if (unionIndex491 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(491, null); + } else { + if (unionIndex491 == 1) { + Utf8 charSequence491; + Object oldString491 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(491); + if (oldString491 instanceof Utf8) { + charSequence491 = (decoder).readString(((Utf8) oldString491)); + } else { + charSequence491 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(491, charSequence491); + } else { + throw new RuntimeException(("Illegal union index for 'F491': "+ unionIndex491)); + } + } + int unionIndex492 = (decoder.readIndex()); + if (unionIndex492 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(492, null); + } else { + if (unionIndex492 == 1) { + Utf8 charSequence492; + Object oldString492 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(492); + if (oldString492 instanceof Utf8) { + charSequence492 = (decoder).readString(((Utf8) oldString492)); + } else { + charSequence492 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(492, charSequence492); + } else { + throw new RuntimeException(("Illegal union index for 'F492': "+ unionIndex492)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex493 = (decoder.readIndex()); + if (unionIndex493 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(493, null); + } else { + if (unionIndex493 == 1) { + Utf8 charSequence493; + Object oldString493 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(493); + if (oldString493 instanceof Utf8) { + charSequence493 = (decoder).readString(((Utf8) oldString493)); + } else { + charSequence493 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(493, charSequence493); + } else { + throw new RuntimeException(("Illegal union index for 'F493': "+ unionIndex493)); + } + } + int unionIndex494 = (decoder.readIndex()); + if (unionIndex494 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(494, null); + } else { + if (unionIndex494 == 1) { + Utf8 charSequence494; + Object oldString494 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(494); + if (oldString494 instanceof Utf8) { + charSequence494 = (decoder).readString(((Utf8) oldString494)); + } else { + charSequence494 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(494, charSequence494); + } else { + throw new RuntimeException(("Illegal union index for 'F494': "+ unionIndex494)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex495 = (decoder.readIndex()); + if (unionIndex495 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(495, null); + } else { + if (unionIndex495 == 1) { + Utf8 charSequence495; + Object oldString495 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(495); + if (oldString495 instanceof Utf8) { + charSequence495 = (decoder).readString(((Utf8) oldString495)); + } else { + charSequence495 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(495, charSequence495); + } else { + throw new RuntimeException(("Illegal union index for 'F495': "+ unionIndex495)); + } + } + int unionIndex496 = (decoder.readIndex()); + if (unionIndex496 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(496, null); + } else { + if (unionIndex496 == 1) { + Utf8 charSequence496; + Object oldString496 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(496); + if (oldString496 instanceof Utf8) { + charSequence496 = (decoder).readString(((Utf8) oldString496)); + } else { + charSequence496 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(496, charSequence496); + } else { + throw new RuntimeException(("Illegal union index for 'F496': "+ unionIndex496)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex497 = (decoder.readIndex()); + if (unionIndex497 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(497, null); + } else { + if (unionIndex497 == 1) { + Utf8 charSequence497; + Object oldString497 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(497); + if (oldString497 instanceof Utf8) { + charSequence497 = (decoder).readString(((Utf8) oldString497)); + } else { + charSequence497 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(497, charSequence497); + } else { + throw new RuntimeException(("Illegal union index for 'F497': "+ unionIndex497)); + } + } + int unionIndex498 = (decoder.readIndex()); + if (unionIndex498 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(498, null); + } else { + if (unionIndex498 == 1) { + Utf8 charSequence498; + Object oldString498 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(498); + if (oldString498 instanceof Utf8) { + charSequence498 = (decoder).readString(((Utf8) oldString498)); + } else { + charSequence498 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(498, charSequence498); + } else { + throw new RuntimeException(("Illegal union index for 'F498': "+ unionIndex498)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex499 = (decoder.readIndex()); + if (unionIndex499 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(499, null); + } else { + if (unionIndex499 == 1) { + Utf8 charSequence499; + Object oldString499 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(499); + if (oldString499 instanceof Utf8) { + charSequence499 = (decoder).readString(((Utf8) oldString499)); + } else { + charSequence499 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(499, charSequence499); + } else { + throw new RuntimeException(("Illegal union index for 'F499': "+ unionIndex499)); + } + } + int unionIndex500 = (decoder.readIndex()); + if (unionIndex500 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(500, null); + } else { + if (unionIndex500 == 1) { + Utf8 charSequence500; + Object oldString500 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(500); + if (oldString500 instanceof Utf8) { + charSequence500 = (decoder).readString(((Utf8) oldString500)); + } else { + charSequence500 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(500, charSequence500); + } else { + throw new RuntimeException(("Illegal union index for 'F500': "+ unionIndex500)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex501 = (decoder.readIndex()); + if (unionIndex501 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(501, null); + } else { + if (unionIndex501 == 1) { + Utf8 charSequence501; + Object oldString501 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(501); + if (oldString501 instanceof Utf8) { + charSequence501 = (decoder).readString(((Utf8) oldString501)); + } else { + charSequence501 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(501, charSequence501); + } else { + throw new RuntimeException(("Illegal union index for 'F501': "+ unionIndex501)); + } + } + int unionIndex502 = (decoder.readIndex()); + if (unionIndex502 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(502, null); + } else { + if (unionIndex502 == 1) { + Utf8 charSequence502; + Object oldString502 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(502); + if (oldString502 instanceof Utf8) { + charSequence502 = (decoder).readString(((Utf8) oldString502)); + } else { + charSequence502 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(502, charSequence502); + } else { + throw new RuntimeException(("Illegal union index for 'F502': "+ unionIndex502)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex503 = (decoder.readIndex()); + if (unionIndex503 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(503, null); + } else { + if (unionIndex503 == 1) { + Utf8 charSequence503; + Object oldString503 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(503); + if (oldString503 instanceof Utf8) { + charSequence503 = (decoder).readString(((Utf8) oldString503)); + } else { + charSequence503 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(503, charSequence503); + } else { + throw new RuntimeException(("Illegal union index for 'F503': "+ unionIndex503)); + } + } + int unionIndex504 = (decoder.readIndex()); + if (unionIndex504 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(504, null); + } else { + if (unionIndex504 == 1) { + Utf8 charSequence504; + Object oldString504 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(504); + if (oldString504 instanceof Utf8) { + charSequence504 = (decoder).readString(((Utf8) oldString504)); + } else { + charSequence504 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(504, charSequence504); + } else { + throw new RuntimeException(("Illegal union index for 'F504': "+ unionIndex504)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex505 = (decoder.readIndex()); + if (unionIndex505 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(505, null); + } else { + if (unionIndex505 == 1) { + Utf8 charSequence505; + Object oldString505 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(505); + if (oldString505 instanceof Utf8) { + charSequence505 = (decoder).readString(((Utf8) oldString505)); + } else { + charSequence505 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(505, charSequence505); + } else { + throw new RuntimeException(("Illegal union index for 'F505': "+ unionIndex505)); + } + } + int unionIndex506 = (decoder.readIndex()); + if (unionIndex506 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(506, null); + } else { + if (unionIndex506 == 1) { + Utf8 charSequence506; + Object oldString506 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(506); + if (oldString506 instanceof Utf8) { + charSequence506 = (decoder).readString(((Utf8) oldString506)); + } else { + charSequence506 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(506, charSequence506); + } else { + throw new RuntimeException(("Illegal union index for 'F506': "+ unionIndex506)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex507 = (decoder.readIndex()); + if (unionIndex507 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(507, null); + } else { + if (unionIndex507 == 1) { + Utf8 charSequence507; + Object oldString507 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(507); + if (oldString507 instanceof Utf8) { + charSequence507 = (decoder).readString(((Utf8) oldString507)); + } else { + charSequence507 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(507, charSequence507); + } else { + throw new RuntimeException(("Illegal union index for 'F507': "+ unionIndex507)); + } + } + int unionIndex508 = (decoder.readIndex()); + if (unionIndex508 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(508, null); + } else { + if (unionIndex508 == 1) { + Utf8 charSequence508; + Object oldString508 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(508); + if (oldString508 instanceof Utf8) { + charSequence508 = (decoder).readString(((Utf8) oldString508)); + } else { + charSequence508 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(508, charSequence508); + } else { + throw new RuntimeException(("Illegal union index for 'F508': "+ unionIndex508)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex509 = (decoder.readIndex()); + if (unionIndex509 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(509, null); + } else { + if (unionIndex509 == 1) { + Utf8 charSequence509; + Object oldString509 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(509); + if (oldString509 instanceof Utf8) { + charSequence509 = (decoder).readString(((Utf8) oldString509)); + } else { + charSequence509 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(509, charSequence509); + } else { + throw new RuntimeException(("Illegal union index for 'F509': "+ unionIndex509)); + } + } + int unionIndex510 = (decoder.readIndex()); + if (unionIndex510 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(510, null); + } else { + if (unionIndex510 == 1) { + Utf8 charSequence510; + Object oldString510 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(510); + if (oldString510 instanceof Utf8) { + charSequence510 = (decoder).readString(((Utf8) oldString510)); + } else { + charSequence510 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(510, charSequence510); + } else { + throw new RuntimeException(("Illegal union index for 'F510': "+ unionIndex510)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex511 = (decoder.readIndex()); + if (unionIndex511 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(511, null); + } else { + if (unionIndex511 == 1) { + Utf8 charSequence511; + Object oldString511 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(511); + if (oldString511 instanceof Utf8) { + charSequence511 = (decoder).readString(((Utf8) oldString511)); + } else { + charSequence511 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(511, charSequence511); + } else { + throw new RuntimeException(("Illegal union index for 'F511': "+ unionIndex511)); + } + } + int unionIndex512 = (decoder.readIndex()); + if (unionIndex512 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(512, null); + } else { + if (unionIndex512 == 1) { + Utf8 charSequence512; + Object oldString512 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(512); + if (oldString512 instanceof Utf8) { + charSequence512 = (decoder).readString(((Utf8) oldString512)); + } else { + charSequence512 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(512, charSequence512); + } else { + throw new RuntimeException(("Illegal union index for 'F512': "+ unionIndex512)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex513 = (decoder.readIndex()); + if (unionIndex513 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(513, null); + } else { + if (unionIndex513 == 1) { + Utf8 charSequence513; + Object oldString513 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(513); + if (oldString513 instanceof Utf8) { + charSequence513 = (decoder).readString(((Utf8) oldString513)); + } else { + charSequence513 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(513, charSequence513); + } else { + throw new RuntimeException(("Illegal union index for 'F513': "+ unionIndex513)); + } + } + int unionIndex514 = (decoder.readIndex()); + if (unionIndex514 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(514, null); + } else { + if (unionIndex514 == 1) { + Utf8 charSequence514; + Object oldString514 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(514); + if (oldString514 instanceof Utf8) { + charSequence514 = (decoder).readString(((Utf8) oldString514)); + } else { + charSequence514 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(514, charSequence514); + } else { + throw new RuntimeException(("Illegal union index for 'F514': "+ unionIndex514)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex515 = (decoder.readIndex()); + if (unionIndex515 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(515, null); + } else { + if (unionIndex515 == 1) { + Utf8 charSequence515; + Object oldString515 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(515); + if (oldString515 instanceof Utf8) { + charSequence515 = (decoder).readString(((Utf8) oldString515)); + } else { + charSequence515 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(515, charSequence515); + } else { + throw new RuntimeException(("Illegal union index for 'F515': "+ unionIndex515)); + } + } + int unionIndex516 = (decoder.readIndex()); + if (unionIndex516 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(516, null); + } else { + if (unionIndex516 == 1) { + Utf8 charSequence516; + Object oldString516 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(516); + if (oldString516 instanceof Utf8) { + charSequence516 = (decoder).readString(((Utf8) oldString516)); + } else { + charSequence516 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(516, charSequence516); + } else { + throw new RuntimeException(("Illegal union index for 'F516': "+ unionIndex516)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex517 = (decoder.readIndex()); + if (unionIndex517 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(517, null); + } else { + if (unionIndex517 == 1) { + Utf8 charSequence517; + Object oldString517 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(517); + if (oldString517 instanceof Utf8) { + charSequence517 = (decoder).readString(((Utf8) oldString517)); + } else { + charSequence517 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(517, charSequence517); + } else { + throw new RuntimeException(("Illegal union index for 'F517': "+ unionIndex517)); + } + } + int unionIndex518 = (decoder.readIndex()); + if (unionIndex518 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(518, null); + } else { + if (unionIndex518 == 1) { + Utf8 charSequence518; + Object oldString518 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(518); + if (oldString518 instanceof Utf8) { + charSequence518 = (decoder).readString(((Utf8) oldString518)); + } else { + charSequence518 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(518, charSequence518); + } else { + throw new RuntimeException(("Illegal union index for 'F518': "+ unionIndex518)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex519 = (decoder.readIndex()); + if (unionIndex519 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(519, null); + } else { + if (unionIndex519 == 1) { + Utf8 charSequence519; + Object oldString519 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(519); + if (oldString519 instanceof Utf8) { + charSequence519 = (decoder).readString(((Utf8) oldString519)); + } else { + charSequence519 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(519, charSequence519); + } else { + throw new RuntimeException(("Illegal union index for 'F519': "+ unionIndex519)); + } + } + int unionIndex520 = (decoder.readIndex()); + if (unionIndex520 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(520, null); + } else { + if (unionIndex520 == 1) { + Utf8 charSequence520; + Object oldString520 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(520); + if (oldString520 instanceof Utf8) { + charSequence520 = (decoder).readString(((Utf8) oldString520)); + } else { + charSequence520 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(520, charSequence520); + } else { + throw new RuntimeException(("Illegal union index for 'F520': "+ unionIndex520)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex521 = (decoder.readIndex()); + if (unionIndex521 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(521, null); + } else { + if (unionIndex521 == 1) { + Utf8 charSequence521; + Object oldString521 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(521); + if (oldString521 instanceof Utf8) { + charSequence521 = (decoder).readString(((Utf8) oldString521)); + } else { + charSequence521 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(521, charSequence521); + } else { + throw new RuntimeException(("Illegal union index for 'F521': "+ unionIndex521)); + } + } + int unionIndex522 = (decoder.readIndex()); + if (unionIndex522 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(522, null); + } else { + if (unionIndex522 == 1) { + Utf8 charSequence522; + Object oldString522 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(522); + if (oldString522 instanceof Utf8) { + charSequence522 = (decoder).readString(((Utf8) oldString522)); + } else { + charSequence522 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(522, charSequence522); + } else { + throw new RuntimeException(("Illegal union index for 'F522': "+ unionIndex522)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex523 = (decoder.readIndex()); + if (unionIndex523 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(523, null); + } else { + if (unionIndex523 == 1) { + Utf8 charSequence523; + Object oldString523 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(523); + if (oldString523 instanceof Utf8) { + charSequence523 = (decoder).readString(((Utf8) oldString523)); + } else { + charSequence523 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(523, charSequence523); + } else { + throw new RuntimeException(("Illegal union index for 'F523': "+ unionIndex523)); + } + } + int unionIndex524 = (decoder.readIndex()); + if (unionIndex524 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(524, null); + } else { + if (unionIndex524 == 1) { + Utf8 charSequence524; + Object oldString524 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(524); + if (oldString524 instanceof Utf8) { + charSequence524 = (decoder).readString(((Utf8) oldString524)); + } else { + charSequence524 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(524, charSequence524); + } else { + throw new RuntimeException(("Illegal union index for 'F524': "+ unionIndex524)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex525 = (decoder.readIndex()); + if (unionIndex525 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(525, null); + } else { + if (unionIndex525 == 1) { + Utf8 charSequence525; + Object oldString525 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(525); + if (oldString525 instanceof Utf8) { + charSequence525 = (decoder).readString(((Utf8) oldString525)); + } else { + charSequence525 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(525, charSequence525); + } else { + throw new RuntimeException(("Illegal union index for 'F525': "+ unionIndex525)); + } + } + int unionIndex526 = (decoder.readIndex()); + if (unionIndex526 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(526, null); + } else { + if (unionIndex526 == 1) { + Utf8 charSequence526; + Object oldString526 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(526); + if (oldString526 instanceof Utf8) { + charSequence526 = (decoder).readString(((Utf8) oldString526)); + } else { + charSequence526 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(526, charSequence526); + } else { + throw new RuntimeException(("Illegal union index for 'F526': "+ unionIndex526)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex527 = (decoder.readIndex()); + if (unionIndex527 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(527, null); + } else { + if (unionIndex527 == 1) { + Utf8 charSequence527; + Object oldString527 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(527); + if (oldString527 instanceof Utf8) { + charSequence527 = (decoder).readString(((Utf8) oldString527)); + } else { + charSequence527 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(527, charSequence527); + } else { + throw new RuntimeException(("Illegal union index for 'F527': "+ unionIndex527)); + } + } + int unionIndex528 = (decoder.readIndex()); + if (unionIndex528 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(528, null); + } else { + if (unionIndex528 == 1) { + Utf8 charSequence528; + Object oldString528 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(528); + if (oldString528 instanceof Utf8) { + charSequence528 = (decoder).readString(((Utf8) oldString528)); + } else { + charSequence528 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(528, charSequence528); + } else { + throw new RuntimeException(("Illegal union index for 'F528': "+ unionIndex528)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex529 = (decoder.readIndex()); + if (unionIndex529 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(529, null); + } else { + if (unionIndex529 == 1) { + Utf8 charSequence529; + Object oldString529 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(529); + if (oldString529 instanceof Utf8) { + charSequence529 = (decoder).readString(((Utf8) oldString529)); + } else { + charSequence529 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(529, charSequence529); + } else { + throw new RuntimeException(("Illegal union index for 'F529': "+ unionIndex529)); + } + } + int unionIndex530 = (decoder.readIndex()); + if (unionIndex530 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(530, null); + } else { + if (unionIndex530 == 1) { + Utf8 charSequence530; + Object oldString530 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(530); + if (oldString530 instanceof Utf8) { + charSequence530 = (decoder).readString(((Utf8) oldString530)); + } else { + charSequence530 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(530, charSequence530); + } else { + throw new RuntimeException(("Illegal union index for 'F530': "+ unionIndex530)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex531 = (decoder.readIndex()); + if (unionIndex531 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(531, null); + } else { + if (unionIndex531 == 1) { + Utf8 charSequence531; + Object oldString531 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(531); + if (oldString531 instanceof Utf8) { + charSequence531 = (decoder).readString(((Utf8) oldString531)); + } else { + charSequence531 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(531, charSequence531); + } else { + throw new RuntimeException(("Illegal union index for 'F531': "+ unionIndex531)); + } + } + int unionIndex532 = (decoder.readIndex()); + if (unionIndex532 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(532, null); + } else { + if (unionIndex532 == 1) { + Utf8 charSequence532; + Object oldString532 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(532); + if (oldString532 instanceof Utf8) { + charSequence532 = (decoder).readString(((Utf8) oldString532)); + } else { + charSequence532 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(532, charSequence532); + } else { + throw new RuntimeException(("Illegal union index for 'F532': "+ unionIndex532)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex533 = (decoder.readIndex()); + if (unionIndex533 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(533, null); + } else { + if (unionIndex533 == 1) { + Utf8 charSequence533; + Object oldString533 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(533); + if (oldString533 instanceof Utf8) { + charSequence533 = (decoder).readString(((Utf8) oldString533)); + } else { + charSequence533 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(533, charSequence533); + } else { + throw new RuntimeException(("Illegal union index for 'F533': "+ unionIndex533)); + } + } + int unionIndex534 = (decoder.readIndex()); + if (unionIndex534 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(534, null); + } else { + if (unionIndex534 == 1) { + Utf8 charSequence534; + Object oldString534 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(534); + if (oldString534 instanceof Utf8) { + charSequence534 = (decoder).readString(((Utf8) oldString534)); + } else { + charSequence534 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(534, charSequence534); + } else { + throw new RuntimeException(("Illegal union index for 'F534': "+ unionIndex534)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex535 = (decoder.readIndex()); + if (unionIndex535 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(535, null); + } else { + if (unionIndex535 == 1) { + Utf8 charSequence535; + Object oldString535 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(535); + if (oldString535 instanceof Utf8) { + charSequence535 = (decoder).readString(((Utf8) oldString535)); + } else { + charSequence535 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(535, charSequence535); + } else { + throw new RuntimeException(("Illegal union index for 'F535': "+ unionIndex535)); + } + } + int unionIndex536 = (decoder.readIndex()); + if (unionIndex536 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(536, null); + } else { + if (unionIndex536 == 1) { + Utf8 charSequence536; + Object oldString536 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(536); + if (oldString536 instanceof Utf8) { + charSequence536 = (decoder).readString(((Utf8) oldString536)); + } else { + charSequence536 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(536, charSequence536); + } else { + throw new RuntimeException(("Illegal union index for 'F536': "+ unionIndex536)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex537 = (decoder.readIndex()); + if (unionIndex537 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(537, null); + } else { + if (unionIndex537 == 1) { + Utf8 charSequence537; + Object oldString537 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(537); + if (oldString537 instanceof Utf8) { + charSequence537 = (decoder).readString(((Utf8) oldString537)); + } else { + charSequence537 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(537, charSequence537); + } else { + throw new RuntimeException(("Illegal union index for 'F537': "+ unionIndex537)); + } + } + int unionIndex538 = (decoder.readIndex()); + if (unionIndex538 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(538, null); + } else { + if (unionIndex538 == 1) { + Utf8 charSequence538; + Object oldString538 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(538); + if (oldString538 instanceof Utf8) { + charSequence538 = (decoder).readString(((Utf8) oldString538)); + } else { + charSequence538 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(538, charSequence538); + } else { + throw new RuntimeException(("Illegal union index for 'F538': "+ unionIndex538)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex539 = (decoder.readIndex()); + if (unionIndex539 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(539, null); + } else { + if (unionIndex539 == 1) { + Utf8 charSequence539; + Object oldString539 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(539); + if (oldString539 instanceof Utf8) { + charSequence539 = (decoder).readString(((Utf8) oldString539)); + } else { + charSequence539 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(539, charSequence539); + } else { + throw new RuntimeException(("Illegal union index for 'F539': "+ unionIndex539)); + } + } + int unionIndex540 = (decoder.readIndex()); + if (unionIndex540 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(540, null); + } else { + if (unionIndex540 == 1) { + Utf8 charSequence540; + Object oldString540 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(540); + if (oldString540 instanceof Utf8) { + charSequence540 = (decoder).readString(((Utf8) oldString540)); + } else { + charSequence540 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(540, charSequence540); + } else { + throw new RuntimeException(("Illegal union index for 'F540': "+ unionIndex540)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex541 = (decoder.readIndex()); + if (unionIndex541 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(541, null); + } else { + if (unionIndex541 == 1) { + Utf8 charSequence541; + Object oldString541 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(541); + if (oldString541 instanceof Utf8) { + charSequence541 = (decoder).readString(((Utf8) oldString541)); + } else { + charSequence541 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(541, charSequence541); + } else { + throw new RuntimeException(("Illegal union index for 'F541': "+ unionIndex541)); + } + } + int unionIndex542 = (decoder.readIndex()); + if (unionIndex542 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(542, null); + } else { + if (unionIndex542 == 1) { + Utf8 charSequence542; + Object oldString542 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(542); + if (oldString542 instanceof Utf8) { + charSequence542 = (decoder).readString(((Utf8) oldString542)); + } else { + charSequence542 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(542, charSequence542); + } else { + throw new RuntimeException(("Illegal union index for 'F542': "+ unionIndex542)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex543 = (decoder.readIndex()); + if (unionIndex543 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(543, null); + } else { + if (unionIndex543 == 1) { + Utf8 charSequence543; + Object oldString543 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(543); + if (oldString543 instanceof Utf8) { + charSequence543 = (decoder).readString(((Utf8) oldString543)); + } else { + charSequence543 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(543, charSequence543); + } else { + throw new RuntimeException(("Illegal union index for 'F543': "+ unionIndex543)); + } + } + int unionIndex544 = (decoder.readIndex()); + if (unionIndex544 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(544, null); + } else { + if (unionIndex544 == 1) { + Utf8 charSequence544; + Object oldString544 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(544); + if (oldString544 instanceof Utf8) { + charSequence544 = (decoder).readString(((Utf8) oldString544)); + } else { + charSequence544 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(544, charSequence544); + } else { + throw new RuntimeException(("Illegal union index for 'F544': "+ unionIndex544)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex545 = (decoder.readIndex()); + if (unionIndex545 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(545, null); + } else { + if (unionIndex545 == 1) { + Utf8 charSequence545; + Object oldString545 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(545); + if (oldString545 instanceof Utf8) { + charSequence545 = (decoder).readString(((Utf8) oldString545)); + } else { + charSequence545 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(545, charSequence545); + } else { + throw new RuntimeException(("Illegal union index for 'F545': "+ unionIndex545)); + } + } + int unionIndex546 = (decoder.readIndex()); + if (unionIndex546 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(546, null); + } else { + if (unionIndex546 == 1) { + Utf8 charSequence546; + Object oldString546 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(546); + if (oldString546 instanceof Utf8) { + charSequence546 = (decoder).readString(((Utf8) oldString546)); + } else { + charSequence546 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(546, charSequence546); + } else { + throw new RuntimeException(("Illegal union index for 'F546': "+ unionIndex546)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex547 = (decoder.readIndex()); + if (unionIndex547 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(547, null); + } else { + if (unionIndex547 == 1) { + Utf8 charSequence547; + Object oldString547 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(547); + if (oldString547 instanceof Utf8) { + charSequence547 = (decoder).readString(((Utf8) oldString547)); + } else { + charSequence547 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(547, charSequence547); + } else { + throw new RuntimeException(("Illegal union index for 'F547': "+ unionIndex547)); + } + } + int unionIndex548 = (decoder.readIndex()); + if (unionIndex548 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(548, null); + } else { + if (unionIndex548 == 1) { + Utf8 charSequence548; + Object oldString548 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(548); + if (oldString548 instanceof Utf8) { + charSequence548 = (decoder).readString(((Utf8) oldString548)); + } else { + charSequence548 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(548, charSequence548); + } else { + throw new RuntimeException(("Illegal union index for 'F548': "+ unionIndex548)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex549 = (decoder.readIndex()); + if (unionIndex549 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(549, null); + } else { + if (unionIndex549 == 1) { + Utf8 charSequence549; + Object oldString549 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(549); + if (oldString549 instanceof Utf8) { + charSequence549 = (decoder).readString(((Utf8) oldString549)); + } else { + charSequence549 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(549, charSequence549); + } else { + throw new RuntimeException(("Illegal union index for 'F549': "+ unionIndex549)); + } + } + int unionIndex550 = (decoder.readIndex()); + if (unionIndex550 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(550, null); + } else { + if (unionIndex550 == 1) { + Utf8 charSequence550; + Object oldString550 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(550); + if (oldString550 instanceof Utf8) { + charSequence550 = (decoder).readString(((Utf8) oldString550)); + } else { + charSequence550 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(550, charSequence550); + } else { + throw new RuntimeException(("Illegal union index for 'F550': "+ unionIndex550)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex551 = (decoder.readIndex()); + if (unionIndex551 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(551, null); + } else { + if (unionIndex551 == 1) { + Utf8 charSequence551; + Object oldString551 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(551); + if (oldString551 instanceof Utf8) { + charSequence551 = (decoder).readString(((Utf8) oldString551)); + } else { + charSequence551 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(551, charSequence551); + } else { + throw new RuntimeException(("Illegal union index for 'F551': "+ unionIndex551)); + } + } + int unionIndex552 = (decoder.readIndex()); + if (unionIndex552 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(552, null); + } else { + if (unionIndex552 == 1) { + Utf8 charSequence552; + Object oldString552 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(552); + if (oldString552 instanceof Utf8) { + charSequence552 = (decoder).readString(((Utf8) oldString552)); + } else { + charSequence552 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(552, charSequence552); + } else { + throw new RuntimeException(("Illegal union index for 'F552': "+ unionIndex552)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex553 = (decoder.readIndex()); + if (unionIndex553 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(553, null); + } else { + if (unionIndex553 == 1) { + Utf8 charSequence553; + Object oldString553 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(553); + if (oldString553 instanceof Utf8) { + charSequence553 = (decoder).readString(((Utf8) oldString553)); + } else { + charSequence553 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(553, charSequence553); + } else { + throw new RuntimeException(("Illegal union index for 'F553': "+ unionIndex553)); + } + } + int unionIndex554 = (decoder.readIndex()); + if (unionIndex554 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(554, null); + } else { + if (unionIndex554 == 1) { + Utf8 charSequence554; + Object oldString554 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(554); + if (oldString554 instanceof Utf8) { + charSequence554 = (decoder).readString(((Utf8) oldString554)); + } else { + charSequence554 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(554, charSequence554); + } else { + throw new RuntimeException(("Illegal union index for 'F554': "+ unionIndex554)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex555 = (decoder.readIndex()); + if (unionIndex555 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(555, null); + } else { + if (unionIndex555 == 1) { + Utf8 charSequence555; + Object oldString555 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(555); + if (oldString555 instanceof Utf8) { + charSequence555 = (decoder).readString(((Utf8) oldString555)); + } else { + charSequence555 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(555, charSequence555); + } else { + throw new RuntimeException(("Illegal union index for 'F555': "+ unionIndex555)); + } + } + int unionIndex556 = (decoder.readIndex()); + if (unionIndex556 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(556, null); + } else { + if (unionIndex556 == 1) { + Utf8 charSequence556; + Object oldString556 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(556); + if (oldString556 instanceof Utf8) { + charSequence556 = (decoder).readString(((Utf8) oldString556)); + } else { + charSequence556 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(556, charSequence556); + } else { + throw new RuntimeException(("Illegal union index for 'F556': "+ unionIndex556)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex557 = (decoder.readIndex()); + if (unionIndex557 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(557, null); + } else { + if (unionIndex557 == 1) { + Utf8 charSequence557; + Object oldString557 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(557); + if (oldString557 instanceof Utf8) { + charSequence557 = (decoder).readString(((Utf8) oldString557)); + } else { + charSequence557 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(557, charSequence557); + } else { + throw new RuntimeException(("Illegal union index for 'F557': "+ unionIndex557)); + } + } + int unionIndex558 = (decoder.readIndex()); + if (unionIndex558 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(558, null); + } else { + if (unionIndex558 == 1) { + Utf8 charSequence558; + Object oldString558 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(558); + if (oldString558 instanceof Utf8) { + charSequence558 = (decoder).readString(((Utf8) oldString558)); + } else { + charSequence558 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(558, charSequence558); + } else { + throw new RuntimeException(("Illegal union index for 'F558': "+ unionIndex558)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex559 = (decoder.readIndex()); + if (unionIndex559 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(559, null); + } else { + if (unionIndex559 == 1) { + Utf8 charSequence559; + Object oldString559 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(559); + if (oldString559 instanceof Utf8) { + charSequence559 = (decoder).readString(((Utf8) oldString559)); + } else { + charSequence559 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(559, charSequence559); + } else { + throw new RuntimeException(("Illegal union index for 'F559': "+ unionIndex559)); + } + } + int unionIndex560 = (decoder.readIndex()); + if (unionIndex560 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(560, null); + } else { + if (unionIndex560 == 1) { + Utf8 charSequence560; + Object oldString560 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(560); + if (oldString560 instanceof Utf8) { + charSequence560 = (decoder).readString(((Utf8) oldString560)); + } else { + charSequence560 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(560, charSequence560); + } else { + throw new RuntimeException(("Illegal union index for 'F560': "+ unionIndex560)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex561 = (decoder.readIndex()); + if (unionIndex561 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(561, null); + } else { + if (unionIndex561 == 1) { + Utf8 charSequence561; + Object oldString561 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(561); + if (oldString561 instanceof Utf8) { + charSequence561 = (decoder).readString(((Utf8) oldString561)); + } else { + charSequence561 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(561, charSequence561); + } else { + throw new RuntimeException(("Illegal union index for 'F561': "+ unionIndex561)); + } + } + int unionIndex562 = (decoder.readIndex()); + if (unionIndex562 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(562, null); + } else { + if (unionIndex562 == 1) { + Utf8 charSequence562; + Object oldString562 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(562); + if (oldString562 instanceof Utf8) { + charSequence562 = (decoder).readString(((Utf8) oldString562)); + } else { + charSequence562 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(562, charSequence562); + } else { + throw new RuntimeException(("Illegal union index for 'F562': "+ unionIndex562)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex563 = (decoder.readIndex()); + if (unionIndex563 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(563, null); + } else { + if (unionIndex563 == 1) { + Utf8 charSequence563; + Object oldString563 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(563); + if (oldString563 instanceof Utf8) { + charSequence563 = (decoder).readString(((Utf8) oldString563)); + } else { + charSequence563 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(563, charSequence563); + } else { + throw new RuntimeException(("Illegal union index for 'F563': "+ unionIndex563)); + } + } + int unionIndex564 = (decoder.readIndex()); + if (unionIndex564 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(564, null); + } else { + if (unionIndex564 == 1) { + Utf8 charSequence564; + Object oldString564 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(564); + if (oldString564 instanceof Utf8) { + charSequence564 = (decoder).readString(((Utf8) oldString564)); + } else { + charSequence564 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(564, charSequence564); + } else { + throw new RuntimeException(("Illegal union index for 'F564': "+ unionIndex564)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex565 = (decoder.readIndex()); + if (unionIndex565 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(565, null); + } else { + if (unionIndex565 == 1) { + Utf8 charSequence565; + Object oldString565 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(565); + if (oldString565 instanceof Utf8) { + charSequence565 = (decoder).readString(((Utf8) oldString565)); + } else { + charSequence565 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(565, charSequence565); + } else { + throw new RuntimeException(("Illegal union index for 'F565': "+ unionIndex565)); + } + } + int unionIndex566 = (decoder.readIndex()); + if (unionIndex566 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(566, null); + } else { + if (unionIndex566 == 1) { + Utf8 charSequence566; + Object oldString566 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(566); + if (oldString566 instanceof Utf8) { + charSequence566 = (decoder).readString(((Utf8) oldString566)); + } else { + charSequence566 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(566, charSequence566); + } else { + throw new RuntimeException(("Illegal union index for 'F566': "+ unionIndex566)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex567 = (decoder.readIndex()); + if (unionIndex567 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(567, null); + } else { + if (unionIndex567 == 1) { + Utf8 charSequence567; + Object oldString567 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(567); + if (oldString567 instanceof Utf8) { + charSequence567 = (decoder).readString(((Utf8) oldString567)); + } else { + charSequence567 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(567, charSequence567); + } else { + throw new RuntimeException(("Illegal union index for 'F567': "+ unionIndex567)); + } + } + int unionIndex568 = (decoder.readIndex()); + if (unionIndex568 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(568, null); + } else { + if (unionIndex568 == 1) { + Utf8 charSequence568; + Object oldString568 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(568); + if (oldString568 instanceof Utf8) { + charSequence568 = (decoder).readString(((Utf8) oldString568)); + } else { + charSequence568 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(568, charSequence568); + } else { + throw new RuntimeException(("Illegal union index for 'F568': "+ unionIndex568)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex569 = (decoder.readIndex()); + if (unionIndex569 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(569, null); + } else { + if (unionIndex569 == 1) { + Utf8 charSequence569; + Object oldString569 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(569); + if (oldString569 instanceof Utf8) { + charSequence569 = (decoder).readString(((Utf8) oldString569)); + } else { + charSequence569 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(569, charSequence569); + } else { + throw new RuntimeException(("Illegal union index for 'F569': "+ unionIndex569)); + } + } + int unionIndex570 = (decoder.readIndex()); + if (unionIndex570 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(570, null); + } else { + if (unionIndex570 == 1) { + Utf8 charSequence570; + Object oldString570 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(570); + if (oldString570 instanceof Utf8) { + charSequence570 = (decoder).readString(((Utf8) oldString570)); + } else { + charSequence570 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(570, charSequence570); + } else { + throw new RuntimeException(("Illegal union index for 'F570': "+ unionIndex570)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex571 = (decoder.readIndex()); + if (unionIndex571 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(571, null); + } else { + if (unionIndex571 == 1) { + Utf8 charSequence571; + Object oldString571 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(571); + if (oldString571 instanceof Utf8) { + charSequence571 = (decoder).readString(((Utf8) oldString571)); + } else { + charSequence571 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(571, charSequence571); + } else { + throw new RuntimeException(("Illegal union index for 'F571': "+ unionIndex571)); + } + } + int unionIndex572 = (decoder.readIndex()); + if (unionIndex572 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(572, null); + } else { + if (unionIndex572 == 1) { + Utf8 charSequence572; + Object oldString572 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(572); + if (oldString572 instanceof Utf8) { + charSequence572 = (decoder).readString(((Utf8) oldString572)); + } else { + charSequence572 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(572, charSequence572); + } else { + throw new RuntimeException(("Illegal union index for 'F572': "+ unionIndex572)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex573 = (decoder.readIndex()); + if (unionIndex573 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(573, null); + } else { + if (unionIndex573 == 1) { + Utf8 charSequence573; + Object oldString573 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(573); + if (oldString573 instanceof Utf8) { + charSequence573 = (decoder).readString(((Utf8) oldString573)); + } else { + charSequence573 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(573, charSequence573); + } else { + throw new RuntimeException(("Illegal union index for 'F573': "+ unionIndex573)); + } + } + int unionIndex574 = (decoder.readIndex()); + if (unionIndex574 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(574, null); + } else { + if (unionIndex574 == 1) { + Utf8 charSequence574; + Object oldString574 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(574); + if (oldString574 instanceof Utf8) { + charSequence574 = (decoder).readString(((Utf8) oldString574)); + } else { + charSequence574 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(574, charSequence574); + } else { + throw new RuntimeException(("Illegal union index for 'F574': "+ unionIndex574)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex575 = (decoder.readIndex()); + if (unionIndex575 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(575, null); + } else { + if (unionIndex575 == 1) { + Utf8 charSequence575; + Object oldString575 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(575); + if (oldString575 instanceof Utf8) { + charSequence575 = (decoder).readString(((Utf8) oldString575)); + } else { + charSequence575 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(575, charSequence575); + } else { + throw new RuntimeException(("Illegal union index for 'F575': "+ unionIndex575)); + } + } + int unionIndex576 = (decoder.readIndex()); + if (unionIndex576 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(576, null); + } else { + if (unionIndex576 == 1) { + Utf8 charSequence576; + Object oldString576 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(576); + if (oldString576 instanceof Utf8) { + charSequence576 = (decoder).readString(((Utf8) oldString576)); + } else { + charSequence576 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(576, charSequence576); + } else { + throw new RuntimeException(("Illegal union index for 'F576': "+ unionIndex576)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex577 = (decoder.readIndex()); + if (unionIndex577 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(577, null); + } else { + if (unionIndex577 == 1) { + Utf8 charSequence577; + Object oldString577 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(577); + if (oldString577 instanceof Utf8) { + charSequence577 = (decoder).readString(((Utf8) oldString577)); + } else { + charSequence577 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(577, charSequence577); + } else { + throw new RuntimeException(("Illegal union index for 'F577': "+ unionIndex577)); + } + } + int unionIndex578 = (decoder.readIndex()); + if (unionIndex578 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(578, null); + } else { + if (unionIndex578 == 1) { + Utf8 charSequence578; + Object oldString578 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(578); + if (oldString578 instanceof Utf8) { + charSequence578 = (decoder).readString(((Utf8) oldString578)); + } else { + charSequence578 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(578, charSequence578); + } else { + throw new RuntimeException(("Illegal union index for 'F578': "+ unionIndex578)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex579 = (decoder.readIndex()); + if (unionIndex579 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(579, null); + } else { + if (unionIndex579 == 1) { + Utf8 charSequence579; + Object oldString579 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(579); + if (oldString579 instanceof Utf8) { + charSequence579 = (decoder).readString(((Utf8) oldString579)); + } else { + charSequence579 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(579, charSequence579); + } else { + throw new RuntimeException(("Illegal union index for 'F579': "+ unionIndex579)); + } + } + int unionIndex580 = (decoder.readIndex()); + if (unionIndex580 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(580, null); + } else { + if (unionIndex580 == 1) { + Utf8 charSequence580; + Object oldString580 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(580); + if (oldString580 instanceof Utf8) { + charSequence580 = (decoder).readString(((Utf8) oldString580)); + } else { + charSequence580 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(580, charSequence580); + } else { + throw new RuntimeException(("Illegal union index for 'F580': "+ unionIndex580)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex581 = (decoder.readIndex()); + if (unionIndex581 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(581, null); + } else { + if (unionIndex581 == 1) { + Utf8 charSequence581; + Object oldString581 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(581); + if (oldString581 instanceof Utf8) { + charSequence581 = (decoder).readString(((Utf8) oldString581)); + } else { + charSequence581 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(581, charSequence581); + } else { + throw new RuntimeException(("Illegal union index for 'F581': "+ unionIndex581)); + } + } + int unionIndex582 = (decoder.readIndex()); + if (unionIndex582 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(582, null); + } else { + if (unionIndex582 == 1) { + Utf8 charSequence582; + Object oldString582 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(582); + if (oldString582 instanceof Utf8) { + charSequence582 = (decoder).readString(((Utf8) oldString582)); + } else { + charSequence582 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(582, charSequence582); + } else { + throw new RuntimeException(("Illegal union index for 'F582': "+ unionIndex582)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex583 = (decoder.readIndex()); + if (unionIndex583 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(583, null); + } else { + if (unionIndex583 == 1) { + Utf8 charSequence583; + Object oldString583 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(583); + if (oldString583 instanceof Utf8) { + charSequence583 = (decoder).readString(((Utf8) oldString583)); + } else { + charSequence583 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(583, charSequence583); + } else { + throw new RuntimeException(("Illegal union index for 'F583': "+ unionIndex583)); + } + } + int unionIndex584 = (decoder.readIndex()); + if (unionIndex584 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(584, null); + } else { + if (unionIndex584 == 1) { + Utf8 charSequence584; + Object oldString584 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(584); + if (oldString584 instanceof Utf8) { + charSequence584 = (decoder).readString(((Utf8) oldString584)); + } else { + charSequence584 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(584, charSequence584); + } else { + throw new RuntimeException(("Illegal union index for 'F584': "+ unionIndex584)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex585 = (decoder.readIndex()); + if (unionIndex585 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(585, null); + } else { + if (unionIndex585 == 1) { + Utf8 charSequence585; + Object oldString585 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(585); + if (oldString585 instanceof Utf8) { + charSequence585 = (decoder).readString(((Utf8) oldString585)); + } else { + charSequence585 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(585, charSequence585); + } else { + throw new RuntimeException(("Illegal union index for 'F585': "+ unionIndex585)); + } + } + int unionIndex586 = (decoder.readIndex()); + if (unionIndex586 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(586, null); + } else { + if (unionIndex586 == 1) { + Utf8 charSequence586; + Object oldString586 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(586); + if (oldString586 instanceof Utf8) { + charSequence586 = (decoder).readString(((Utf8) oldString586)); + } else { + charSequence586 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(586, charSequence586); + } else { + throw new RuntimeException(("Illegal union index for 'F586': "+ unionIndex586)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex587 = (decoder.readIndex()); + if (unionIndex587 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(587, null); + } else { + if (unionIndex587 == 1) { + Utf8 charSequence587; + Object oldString587 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(587); + if (oldString587 instanceof Utf8) { + charSequence587 = (decoder).readString(((Utf8) oldString587)); + } else { + charSequence587 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(587, charSequence587); + } else { + throw new RuntimeException(("Illegal union index for 'F587': "+ unionIndex587)); + } + } + int unionIndex588 = (decoder.readIndex()); + if (unionIndex588 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(588, null); + } else { + if (unionIndex588 == 1) { + Utf8 charSequence588; + Object oldString588 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(588); + if (oldString588 instanceof Utf8) { + charSequence588 = (decoder).readString(((Utf8) oldString588)); + } else { + charSequence588 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(588, charSequence588); + } else { + throw new RuntimeException(("Illegal union index for 'F588': "+ unionIndex588)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex589 = (decoder.readIndex()); + if (unionIndex589 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(589, null); + } else { + if (unionIndex589 == 1) { + Utf8 charSequence589; + Object oldString589 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(589); + if (oldString589 instanceof Utf8) { + charSequence589 = (decoder).readString(((Utf8) oldString589)); + } else { + charSequence589 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(589, charSequence589); + } else { + throw new RuntimeException(("Illegal union index for 'F589': "+ unionIndex589)); + } + } + int unionIndex590 = (decoder.readIndex()); + if (unionIndex590 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(590, null); + } else { + if (unionIndex590 == 1) { + Utf8 charSequence590; + Object oldString590 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(590); + if (oldString590 instanceof Utf8) { + charSequence590 = (decoder).readString(((Utf8) oldString590)); + } else { + charSequence590 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(590, charSequence590); + } else { + throw new RuntimeException(("Illegal union index for 'F590': "+ unionIndex590)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex591 = (decoder.readIndex()); + if (unionIndex591 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(591, null); + } else { + if (unionIndex591 == 1) { + Utf8 charSequence591; + Object oldString591 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(591); + if (oldString591 instanceof Utf8) { + charSequence591 = (decoder).readString(((Utf8) oldString591)); + } else { + charSequence591 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(591, charSequence591); + } else { + throw new RuntimeException(("Illegal union index for 'F591': "+ unionIndex591)); + } + } + int unionIndex592 = (decoder.readIndex()); + if (unionIndex592 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(592, null); + } else { + if (unionIndex592 == 1) { + Utf8 charSequence592; + Object oldString592 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(592); + if (oldString592 instanceof Utf8) { + charSequence592 = (decoder).readString(((Utf8) oldString592)); + } else { + charSequence592 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(592, charSequence592); + } else { + throw new RuntimeException(("Illegal union index for 'F592': "+ unionIndex592)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex593 = (decoder.readIndex()); + if (unionIndex593 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(593, null); + } else { + if (unionIndex593 == 1) { + Utf8 charSequence593; + Object oldString593 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(593); + if (oldString593 instanceof Utf8) { + charSequence593 = (decoder).readString(((Utf8) oldString593)); + } else { + charSequence593 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(593, charSequence593); + } else { + throw new RuntimeException(("Illegal union index for 'F593': "+ unionIndex593)); + } + } + int unionIndex594 = (decoder.readIndex()); + if (unionIndex594 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(594, null); + } else { + if (unionIndex594 == 1) { + Utf8 charSequence594; + Object oldString594 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(594); + if (oldString594 instanceof Utf8) { + charSequence594 = (decoder).readString(((Utf8) oldString594)); + } else { + charSequence594 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(594, charSequence594); + } else { + throw new RuntimeException(("Illegal union index for 'F594': "+ unionIndex594)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex595 = (decoder.readIndex()); + if (unionIndex595 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(595, null); + } else { + if (unionIndex595 == 1) { + Utf8 charSequence595; + Object oldString595 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(595); + if (oldString595 instanceof Utf8) { + charSequence595 = (decoder).readString(((Utf8) oldString595)); + } else { + charSequence595 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(595, charSequence595); + } else { + throw new RuntimeException(("Illegal union index for 'F595': "+ unionIndex595)); + } + } + int unionIndex596 = (decoder.readIndex()); + if (unionIndex596 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(596, null); + } else { + if (unionIndex596 == 1) { + Utf8 charSequence596; + Object oldString596 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(596); + if (oldString596 instanceof Utf8) { + charSequence596 = (decoder).readString(((Utf8) oldString596)); + } else { + charSequence596 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(596, charSequence596); + } else { + throw new RuntimeException(("Illegal union index for 'F596': "+ unionIndex596)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex597 = (decoder.readIndex()); + if (unionIndex597 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(597, null); + } else { + if (unionIndex597 == 1) { + Utf8 charSequence597; + Object oldString597 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(597); + if (oldString597 instanceof Utf8) { + charSequence597 = (decoder).readString(((Utf8) oldString597)); + } else { + charSequence597 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(597, charSequence597); + } else { + throw new RuntimeException(("Illegal union index for 'F597': "+ unionIndex597)); + } + } + int unionIndex598 = (decoder.readIndex()); + if (unionIndex598 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(598, null); + } else { + if (unionIndex598 == 1) { + Utf8 charSequence598; + Object oldString598 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(598); + if (oldString598 instanceof Utf8) { + charSequence598 = (decoder).readString(((Utf8) oldString598)); + } else { + charSequence598 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(598, charSequence598); + } else { + throw new RuntimeException(("Illegal union index for 'F598': "+ unionIndex598)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex599 = (decoder.readIndex()); + if (unionIndex599 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(599, null); + } else { + if (unionIndex599 == 1) { + Utf8 charSequence599; + Object oldString599 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(599); + if (oldString599 instanceof Utf8) { + charSequence599 = (decoder).readString(((Utf8) oldString599)); + } else { + charSequence599 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(599, charSequence599); + } else { + throw new RuntimeException(("Illegal union index for 'F599': "+ unionIndex599)); + } + } + int unionIndex600 = (decoder.readIndex()); + if (unionIndex600 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(600, null); + } else { + if (unionIndex600 == 1) { + Utf8 charSequence600; + Object oldString600 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(600); + if (oldString600 instanceof Utf8) { + charSequence600 = (decoder).readString(((Utf8) oldString600)); + } else { + charSequence600 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(600, charSequence600); + } else { + throw new RuntimeException(("Illegal union index for 'F600': "+ unionIndex600)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex601 = (decoder.readIndex()); + if (unionIndex601 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(601, null); + } else { + if (unionIndex601 == 1) { + Utf8 charSequence601; + Object oldString601 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(601); + if (oldString601 instanceof Utf8) { + charSequence601 = (decoder).readString(((Utf8) oldString601)); + } else { + charSequence601 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(601, charSequence601); + } else { + throw new RuntimeException(("Illegal union index for 'F601': "+ unionIndex601)); + } + } + int unionIndex602 = (decoder.readIndex()); + if (unionIndex602 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(602, null); + } else { + if (unionIndex602 == 1) { + Utf8 charSequence602; + Object oldString602 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(602); + if (oldString602 instanceof Utf8) { + charSequence602 = (decoder).readString(((Utf8) oldString602)); + } else { + charSequence602 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(602, charSequence602); + } else { + throw new RuntimeException(("Illegal union index for 'F602': "+ unionIndex602)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex603 = (decoder.readIndex()); + if (unionIndex603 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(603, null); + } else { + if (unionIndex603 == 1) { + Utf8 charSequence603; + Object oldString603 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(603); + if (oldString603 instanceof Utf8) { + charSequence603 = (decoder).readString(((Utf8) oldString603)); + } else { + charSequence603 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(603, charSequence603); + } else { + throw new RuntimeException(("Illegal union index for 'F603': "+ unionIndex603)); + } + } + int unionIndex604 = (decoder.readIndex()); + if (unionIndex604 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(604, null); + } else { + if (unionIndex604 == 1) { + Utf8 charSequence604; + Object oldString604 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(604); + if (oldString604 instanceof Utf8) { + charSequence604 = (decoder).readString(((Utf8) oldString604)); + } else { + charSequence604 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(604, charSequence604); + } else { + throw new RuntimeException(("Illegal union index for 'F604': "+ unionIndex604)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex605 = (decoder.readIndex()); + if (unionIndex605 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(605, null); + } else { + if (unionIndex605 == 1) { + Utf8 charSequence605; + Object oldString605 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(605); + if (oldString605 instanceof Utf8) { + charSequence605 = (decoder).readString(((Utf8) oldString605)); + } else { + charSequence605 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(605, charSequence605); + } else { + throw new RuntimeException(("Illegal union index for 'F605': "+ unionIndex605)); + } + } + int unionIndex606 = (decoder.readIndex()); + if (unionIndex606 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(606, null); + } else { + if (unionIndex606 == 1) { + Utf8 charSequence606; + Object oldString606 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(606); + if (oldString606 instanceof Utf8) { + charSequence606 = (decoder).readString(((Utf8) oldString606)); + } else { + charSequence606 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(606, charSequence606); + } else { + throw new RuntimeException(("Illegal union index for 'F606': "+ unionIndex606)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex607 = (decoder.readIndex()); + if (unionIndex607 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(607, null); + } else { + if (unionIndex607 == 1) { + Utf8 charSequence607; + Object oldString607 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(607); + if (oldString607 instanceof Utf8) { + charSequence607 = (decoder).readString(((Utf8) oldString607)); + } else { + charSequence607 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(607, charSequence607); + } else { + throw new RuntimeException(("Illegal union index for 'F607': "+ unionIndex607)); + } + } + int unionIndex608 = (decoder.readIndex()); + if (unionIndex608 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(608, null); + } else { + if (unionIndex608 == 1) { + Utf8 charSequence608; + Object oldString608 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(608); + if (oldString608 instanceof Utf8) { + charSequence608 = (decoder).readString(((Utf8) oldString608)); + } else { + charSequence608 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(608, charSequence608); + } else { + throw new RuntimeException(("Illegal union index for 'F608': "+ unionIndex608)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex609 = (decoder.readIndex()); + if (unionIndex609 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(609, null); + } else { + if (unionIndex609 == 1) { + Utf8 charSequence609; + Object oldString609 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(609); + if (oldString609 instanceof Utf8) { + charSequence609 = (decoder).readString(((Utf8) oldString609)); + } else { + charSequence609 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(609, charSequence609); + } else { + throw new RuntimeException(("Illegal union index for 'F609': "+ unionIndex609)); + } + } + int unionIndex610 = (decoder.readIndex()); + if (unionIndex610 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(610, null); + } else { + if (unionIndex610 == 1) { + Utf8 charSequence610; + Object oldString610 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(610); + if (oldString610 instanceof Utf8) { + charSequence610 = (decoder).readString(((Utf8) oldString610)); + } else { + charSequence610 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(610, charSequence610); + } else { + throw new RuntimeException(("Illegal union index for 'F610': "+ unionIndex610)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex611 = (decoder.readIndex()); + if (unionIndex611 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(611, null); + } else { + if (unionIndex611 == 1) { + Utf8 charSequence611; + Object oldString611 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(611); + if (oldString611 instanceof Utf8) { + charSequence611 = (decoder).readString(((Utf8) oldString611)); + } else { + charSequence611 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(611, charSequence611); + } else { + throw new RuntimeException(("Illegal union index for 'F611': "+ unionIndex611)); + } + } + int unionIndex612 = (decoder.readIndex()); + if (unionIndex612 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(612, null); + } else { + if (unionIndex612 == 1) { + Utf8 charSequence612; + Object oldString612 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(612); + if (oldString612 instanceof Utf8) { + charSequence612 = (decoder).readString(((Utf8) oldString612)); + } else { + charSequence612 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(612, charSequence612); + } else { + throw new RuntimeException(("Illegal union index for 'F612': "+ unionIndex612)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex613 = (decoder.readIndex()); + if (unionIndex613 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(613, null); + } else { + if (unionIndex613 == 1) { + Utf8 charSequence613; + Object oldString613 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(613); + if (oldString613 instanceof Utf8) { + charSequence613 = (decoder).readString(((Utf8) oldString613)); + } else { + charSequence613 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(613, charSequence613); + } else { + throw new RuntimeException(("Illegal union index for 'F613': "+ unionIndex613)); + } + } + int unionIndex614 = (decoder.readIndex()); + if (unionIndex614 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(614, null); + } else { + if (unionIndex614 == 1) { + Utf8 charSequence614; + Object oldString614 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(614); + if (oldString614 instanceof Utf8) { + charSequence614 = (decoder).readString(((Utf8) oldString614)); + } else { + charSequence614 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(614, charSequence614); + } else { + throw new RuntimeException(("Illegal union index for 'F614': "+ unionIndex614)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex615 = (decoder.readIndex()); + if (unionIndex615 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(615, null); + } else { + if (unionIndex615 == 1) { + Utf8 charSequence615; + Object oldString615 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(615); + if (oldString615 instanceof Utf8) { + charSequence615 = (decoder).readString(((Utf8) oldString615)); + } else { + charSequence615 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(615, charSequence615); + } else { + throw new RuntimeException(("Illegal union index for 'F615': "+ unionIndex615)); + } + } + int unionIndex616 = (decoder.readIndex()); + if (unionIndex616 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(616, null); + } else { + if (unionIndex616 == 1) { + Utf8 charSequence616; + Object oldString616 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(616); + if (oldString616 instanceof Utf8) { + charSequence616 = (decoder).readString(((Utf8) oldString616)); + } else { + charSequence616 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(616, charSequence616); + } else { + throw new RuntimeException(("Illegal union index for 'F616': "+ unionIndex616)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex617 = (decoder.readIndex()); + if (unionIndex617 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(617, null); + } else { + if (unionIndex617 == 1) { + Utf8 charSequence617; + Object oldString617 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(617); + if (oldString617 instanceof Utf8) { + charSequence617 = (decoder).readString(((Utf8) oldString617)); + } else { + charSequence617 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(617, charSequence617); + } else { + throw new RuntimeException(("Illegal union index for 'F617': "+ unionIndex617)); + } + } + int unionIndex618 = (decoder.readIndex()); + if (unionIndex618 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(618, null); + } else { + if (unionIndex618 == 1) { + Utf8 charSequence618; + Object oldString618 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(618); + if (oldString618 instanceof Utf8) { + charSequence618 = (decoder).readString(((Utf8) oldString618)); + } else { + charSequence618 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(618, charSequence618); + } else { + throw new RuntimeException(("Illegal union index for 'F618': "+ unionIndex618)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex619 = (decoder.readIndex()); + if (unionIndex619 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(619, null); + } else { + if (unionIndex619 == 1) { + Utf8 charSequence619; + Object oldString619 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(619); + if (oldString619 instanceof Utf8) { + charSequence619 = (decoder).readString(((Utf8) oldString619)); + } else { + charSequence619 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(619, charSequence619); + } else { + throw new RuntimeException(("Illegal union index for 'F619': "+ unionIndex619)); + } + } + int unionIndex620 = (decoder.readIndex()); + if (unionIndex620 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(620, null); + } else { + if (unionIndex620 == 1) { + Utf8 charSequence620; + Object oldString620 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(620); + if (oldString620 instanceof Utf8) { + charSequence620 = (decoder).readString(((Utf8) oldString620)); + } else { + charSequence620 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(620, charSequence620); + } else { + throw new RuntimeException(("Illegal union index for 'F620': "+ unionIndex620)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex621 = (decoder.readIndex()); + if (unionIndex621 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(621, null); + } else { + if (unionIndex621 == 1) { + Utf8 charSequence621; + Object oldString621 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(621); + if (oldString621 instanceof Utf8) { + charSequence621 = (decoder).readString(((Utf8) oldString621)); + } else { + charSequence621 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(621, charSequence621); + } else { + throw new RuntimeException(("Illegal union index for 'F621': "+ unionIndex621)); + } + } + int unionIndex622 = (decoder.readIndex()); + if (unionIndex622 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(622, null); + } else { + if (unionIndex622 == 1) { + Utf8 charSequence622; + Object oldString622 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(622); + if (oldString622 instanceof Utf8) { + charSequence622 = (decoder).readString(((Utf8) oldString622)); + } else { + charSequence622 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(622, charSequence622); + } else { + throw new RuntimeException(("Illegal union index for 'F622': "+ unionIndex622)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex623 = (decoder.readIndex()); + if (unionIndex623 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(623, null); + } else { + if (unionIndex623 == 1) { + Utf8 charSequence623; + Object oldString623 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(623); + if (oldString623 instanceof Utf8) { + charSequence623 = (decoder).readString(((Utf8) oldString623)); + } else { + charSequence623 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(623, charSequence623); + } else { + throw new RuntimeException(("Illegal union index for 'F623': "+ unionIndex623)); + } + } + int unionIndex624 = (decoder.readIndex()); + if (unionIndex624 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(624, null); + } else { + if (unionIndex624 == 1) { + Utf8 charSequence624; + Object oldString624 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(624); + if (oldString624 instanceof Utf8) { + charSequence624 = (decoder).readString(((Utf8) oldString624)); + } else { + charSequence624 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(624, charSequence624); + } else { + throw new RuntimeException(("Illegal union index for 'F624': "+ unionIndex624)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex625 = (decoder.readIndex()); + if (unionIndex625 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(625, null); + } else { + if (unionIndex625 == 1) { + Utf8 charSequence625; + Object oldString625 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(625); + if (oldString625 instanceof Utf8) { + charSequence625 = (decoder).readString(((Utf8) oldString625)); + } else { + charSequence625 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(625, charSequence625); + } else { + throw new RuntimeException(("Illegal union index for 'F625': "+ unionIndex625)); + } + } + int unionIndex626 = (decoder.readIndex()); + if (unionIndex626 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(626, null); + } else { + if (unionIndex626 == 1) { + Utf8 charSequence626; + Object oldString626 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(626); + if (oldString626 instanceof Utf8) { + charSequence626 = (decoder).readString(((Utf8) oldString626)); + } else { + charSequence626 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(626, charSequence626); + } else { + throw new RuntimeException(("Illegal union index for 'F626': "+ unionIndex626)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex627 = (decoder.readIndex()); + if (unionIndex627 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(627, null); + } else { + if (unionIndex627 == 1) { + Utf8 charSequence627; + Object oldString627 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(627); + if (oldString627 instanceof Utf8) { + charSequence627 = (decoder).readString(((Utf8) oldString627)); + } else { + charSequence627 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(627, charSequence627); + } else { + throw new RuntimeException(("Illegal union index for 'F627': "+ unionIndex627)); + } + } + int unionIndex628 = (decoder.readIndex()); + if (unionIndex628 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(628, null); + } else { + if (unionIndex628 == 1) { + Utf8 charSequence628; + Object oldString628 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(628); + if (oldString628 instanceof Utf8) { + charSequence628 = (decoder).readString(((Utf8) oldString628)); + } else { + charSequence628 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(628, charSequence628); + } else { + throw new RuntimeException(("Illegal union index for 'F628': "+ unionIndex628)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex629 = (decoder.readIndex()); + if (unionIndex629 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(629, null); + } else { + if (unionIndex629 == 1) { + Utf8 charSequence629; + Object oldString629 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(629); + if (oldString629 instanceof Utf8) { + charSequence629 = (decoder).readString(((Utf8) oldString629)); + } else { + charSequence629 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(629, charSequence629); + } else { + throw new RuntimeException(("Illegal union index for 'F629': "+ unionIndex629)); + } + } + int unionIndex630 = (decoder.readIndex()); + if (unionIndex630 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(630, null); + } else { + if (unionIndex630 == 1) { + Utf8 charSequence630; + Object oldString630 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(630); + if (oldString630 instanceof Utf8) { + charSequence630 = (decoder).readString(((Utf8) oldString630)); + } else { + charSequence630 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(630, charSequence630); + } else { + throw new RuntimeException(("Illegal union index for 'F630': "+ unionIndex630)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex631 = (decoder.readIndex()); + if (unionIndex631 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(631, null); + } else { + if (unionIndex631 == 1) { + Utf8 charSequence631; + Object oldString631 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(631); + if (oldString631 instanceof Utf8) { + charSequence631 = (decoder).readString(((Utf8) oldString631)); + } else { + charSequence631 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(631, charSequence631); + } else { + throw new RuntimeException(("Illegal union index for 'F631': "+ unionIndex631)); + } + } + int unionIndex632 = (decoder.readIndex()); + if (unionIndex632 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(632, null); + } else { + if (unionIndex632 == 1) { + Utf8 charSequence632; + Object oldString632 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(632); + if (oldString632 instanceof Utf8) { + charSequence632 = (decoder).readString(((Utf8) oldString632)); + } else { + charSequence632 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(632, charSequence632); + } else { + throw new RuntimeException(("Illegal union index for 'F632': "+ unionIndex632)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex633 = (decoder.readIndex()); + if (unionIndex633 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(633, null); + } else { + if (unionIndex633 == 1) { + Utf8 charSequence633; + Object oldString633 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(633); + if (oldString633 instanceof Utf8) { + charSequence633 = (decoder).readString(((Utf8) oldString633)); + } else { + charSequence633 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(633, charSequence633); + } else { + throw new RuntimeException(("Illegal union index for 'F633': "+ unionIndex633)); + } + } + int unionIndex634 = (decoder.readIndex()); + if (unionIndex634 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(634, null); + } else { + if (unionIndex634 == 1) { + Utf8 charSequence634; + Object oldString634 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(634); + if (oldString634 instanceof Utf8) { + charSequence634 = (decoder).readString(((Utf8) oldString634)); + } else { + charSequence634 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(634, charSequence634); + } else { + throw new RuntimeException(("Illegal union index for 'F634': "+ unionIndex634)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex635 = (decoder.readIndex()); + if (unionIndex635 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(635, null); + } else { + if (unionIndex635 == 1) { + Utf8 charSequence635; + Object oldString635 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(635); + if (oldString635 instanceof Utf8) { + charSequence635 = (decoder).readString(((Utf8) oldString635)); + } else { + charSequence635 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(635, charSequence635); + } else { + throw new RuntimeException(("Illegal union index for 'F635': "+ unionIndex635)); + } + } + int unionIndex636 = (decoder.readIndex()); + if (unionIndex636 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(636, null); + } else { + if (unionIndex636 == 1) { + Utf8 charSequence636; + Object oldString636 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(636); + if (oldString636 instanceof Utf8) { + charSequence636 = (decoder).readString(((Utf8) oldString636)); + } else { + charSequence636 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(636, charSequence636); + } else { + throw new RuntimeException(("Illegal union index for 'F636': "+ unionIndex636)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex637 = (decoder.readIndex()); + if (unionIndex637 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(637, null); + } else { + if (unionIndex637 == 1) { + Utf8 charSequence637; + Object oldString637 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(637); + if (oldString637 instanceof Utf8) { + charSequence637 = (decoder).readString(((Utf8) oldString637)); + } else { + charSequence637 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(637, charSequence637); + } else { + throw new RuntimeException(("Illegal union index for 'F637': "+ unionIndex637)); + } + } + int unionIndex638 = (decoder.readIndex()); + if (unionIndex638 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(638, null); + } else { + if (unionIndex638 == 1) { + Utf8 charSequence638; + Object oldString638 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(638); + if (oldString638 instanceof Utf8) { + charSequence638 = (decoder).readString(((Utf8) oldString638)); + } else { + charSequence638 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(638, charSequence638); + } else { + throw new RuntimeException(("Illegal union index for 'F638': "+ unionIndex638)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex639 = (decoder.readIndex()); + if (unionIndex639 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(639, null); + } else { + if (unionIndex639 == 1) { + Utf8 charSequence639; + Object oldString639 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(639); + if (oldString639 instanceof Utf8) { + charSequence639 = (decoder).readString(((Utf8) oldString639)); + } else { + charSequence639 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(639, charSequence639); + } else { + throw new RuntimeException(("Illegal union index for 'F639': "+ unionIndex639)); + } + } + int unionIndex640 = (decoder.readIndex()); + if (unionIndex640 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(640, null); + } else { + if (unionIndex640 == 1) { + Utf8 charSequence640; + Object oldString640 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(640); + if (oldString640 instanceof Utf8) { + charSequence640 = (decoder).readString(((Utf8) oldString640)); + } else { + charSequence640 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(640, charSequence640); + } else { + throw new RuntimeException(("Illegal union index for 'F640': "+ unionIndex640)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex641 = (decoder.readIndex()); + if (unionIndex641 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(641, null); + } else { + if (unionIndex641 == 1) { + Utf8 charSequence641; + Object oldString641 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(641); + if (oldString641 instanceof Utf8) { + charSequence641 = (decoder).readString(((Utf8) oldString641)); + } else { + charSequence641 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(641, charSequence641); + } else { + throw new RuntimeException(("Illegal union index for 'F641': "+ unionIndex641)); + } + } + int unionIndex642 = (decoder.readIndex()); + if (unionIndex642 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(642, null); + } else { + if (unionIndex642 == 1) { + Utf8 charSequence642; + Object oldString642 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(642); + if (oldString642 instanceof Utf8) { + charSequence642 = (decoder).readString(((Utf8) oldString642)); + } else { + charSequence642 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(642, charSequence642); + } else { + throw new RuntimeException(("Illegal union index for 'F642': "+ unionIndex642)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex643 = (decoder.readIndex()); + if (unionIndex643 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(643, null); + } else { + if (unionIndex643 == 1) { + Utf8 charSequence643; + Object oldString643 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(643); + if (oldString643 instanceof Utf8) { + charSequence643 = (decoder).readString(((Utf8) oldString643)); + } else { + charSequence643 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(643, charSequence643); + } else { + throw new RuntimeException(("Illegal union index for 'F643': "+ unionIndex643)); + } + } + int unionIndex644 = (decoder.readIndex()); + if (unionIndex644 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(644, null); + } else { + if (unionIndex644 == 1) { + Utf8 charSequence644; + Object oldString644 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(644); + if (oldString644 instanceof Utf8) { + charSequence644 = (decoder).readString(((Utf8) oldString644)); + } else { + charSequence644 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(644, charSequence644); + } else { + throw new RuntimeException(("Illegal union index for 'F644': "+ unionIndex644)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex645 = (decoder.readIndex()); + if (unionIndex645 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(645, null); + } else { + if (unionIndex645 == 1) { + Utf8 charSequence645; + Object oldString645 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(645); + if (oldString645 instanceof Utf8) { + charSequence645 = (decoder).readString(((Utf8) oldString645)); + } else { + charSequence645 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(645, charSequence645); + } else { + throw new RuntimeException(("Illegal union index for 'F645': "+ unionIndex645)); + } + } + int unionIndex646 = (decoder.readIndex()); + if (unionIndex646 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(646, null); + } else { + if (unionIndex646 == 1) { + Utf8 charSequence646; + Object oldString646 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(646); + if (oldString646 instanceof Utf8) { + charSequence646 = (decoder).readString(((Utf8) oldString646)); + } else { + charSequence646 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(646, charSequence646); + } else { + throw new RuntimeException(("Illegal union index for 'F646': "+ unionIndex646)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex647 = (decoder.readIndex()); + if (unionIndex647 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(647, null); + } else { + if (unionIndex647 == 1) { + Utf8 charSequence647; + Object oldString647 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(647); + if (oldString647 instanceof Utf8) { + charSequence647 = (decoder).readString(((Utf8) oldString647)); + } else { + charSequence647 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(647, charSequence647); + } else { + throw new RuntimeException(("Illegal union index for 'F647': "+ unionIndex647)); + } + } + int unionIndex648 = (decoder.readIndex()); + if (unionIndex648 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(648, null); + } else { + if (unionIndex648 == 1) { + Utf8 charSequence648; + Object oldString648 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(648); + if (oldString648 instanceof Utf8) { + charSequence648 = (decoder).readString(((Utf8) oldString648)); + } else { + charSequence648 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(648, charSequence648); + } else { + throw new RuntimeException(("Illegal union index for 'F648': "+ unionIndex648)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex649 = (decoder.readIndex()); + if (unionIndex649 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(649, null); + } else { + if (unionIndex649 == 1) { + Utf8 charSequence649; + Object oldString649 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(649); + if (oldString649 instanceof Utf8) { + charSequence649 = (decoder).readString(((Utf8) oldString649)); + } else { + charSequence649 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(649, charSequence649); + } else { + throw new RuntimeException(("Illegal union index for 'F649': "+ unionIndex649)); + } + } + int unionIndex650 = (decoder.readIndex()); + if (unionIndex650 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(650, null); + } else { + if (unionIndex650 == 1) { + Utf8 charSequence650; + Object oldString650 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(650); + if (oldString650 instanceof Utf8) { + charSequence650 = (decoder).readString(((Utf8) oldString650)); + } else { + charSequence650 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(650, charSequence650); + } else { + throw new RuntimeException(("Illegal union index for 'F650': "+ unionIndex650)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex651 = (decoder.readIndex()); + if (unionIndex651 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(651, null); + } else { + if (unionIndex651 == 1) { + Utf8 charSequence651; + Object oldString651 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(651); + if (oldString651 instanceof Utf8) { + charSequence651 = (decoder).readString(((Utf8) oldString651)); + } else { + charSequence651 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(651, charSequence651); + } else { + throw new RuntimeException(("Illegal union index for 'F651': "+ unionIndex651)); + } + } + int unionIndex652 = (decoder.readIndex()); + if (unionIndex652 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(652, null); + } else { + if (unionIndex652 == 1) { + Utf8 charSequence652; + Object oldString652 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(652); + if (oldString652 instanceof Utf8) { + charSequence652 = (decoder).readString(((Utf8) oldString652)); + } else { + charSequence652 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(652, charSequence652); + } else { + throw new RuntimeException(("Illegal union index for 'F652': "+ unionIndex652)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex653 = (decoder.readIndex()); + if (unionIndex653 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(653, null); + } else { + if (unionIndex653 == 1) { + Utf8 charSequence653; + Object oldString653 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(653); + if (oldString653 instanceof Utf8) { + charSequence653 = (decoder).readString(((Utf8) oldString653)); + } else { + charSequence653 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(653, charSequence653); + } else { + throw new RuntimeException(("Illegal union index for 'F653': "+ unionIndex653)); + } + } + int unionIndex654 = (decoder.readIndex()); + if (unionIndex654 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(654, null); + } else { + if (unionIndex654 == 1) { + Utf8 charSequence654; + Object oldString654 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(654); + if (oldString654 instanceof Utf8) { + charSequence654 = (decoder).readString(((Utf8) oldString654)); + } else { + charSequence654 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(654, charSequence654); + } else { + throw new RuntimeException(("Illegal union index for 'F654': "+ unionIndex654)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex655 = (decoder.readIndex()); + if (unionIndex655 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(655, null); + } else { + if (unionIndex655 == 1) { + Utf8 charSequence655; + Object oldString655 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(655); + if (oldString655 instanceof Utf8) { + charSequence655 = (decoder).readString(((Utf8) oldString655)); + } else { + charSequence655 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(655, charSequence655); + } else { + throw new RuntimeException(("Illegal union index for 'F655': "+ unionIndex655)); + } + } + int unionIndex656 = (decoder.readIndex()); + if (unionIndex656 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(656, null); + } else { + if (unionIndex656 == 1) { + Utf8 charSequence656; + Object oldString656 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(656); + if (oldString656 instanceof Utf8) { + charSequence656 = (decoder).readString(((Utf8) oldString656)); + } else { + charSequence656 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(656, charSequence656); + } else { + throw new RuntimeException(("Illegal union index for 'F656': "+ unionIndex656)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex657 = (decoder.readIndex()); + if (unionIndex657 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(657, null); + } else { + if (unionIndex657 == 1) { + Utf8 charSequence657; + Object oldString657 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(657); + if (oldString657 instanceof Utf8) { + charSequence657 = (decoder).readString(((Utf8) oldString657)); + } else { + charSequence657 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(657, charSequence657); + } else { + throw new RuntimeException(("Illegal union index for 'F657': "+ unionIndex657)); + } + } + int unionIndex658 = (decoder.readIndex()); + if (unionIndex658 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(658, null); + } else { + if (unionIndex658 == 1) { + Utf8 charSequence658; + Object oldString658 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(658); + if (oldString658 instanceof Utf8) { + charSequence658 = (decoder).readString(((Utf8) oldString658)); + } else { + charSequence658 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(658, charSequence658); + } else { + throw new RuntimeException(("Illegal union index for 'F658': "+ unionIndex658)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex659 = (decoder.readIndex()); + if (unionIndex659 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(659, null); + } else { + if (unionIndex659 == 1) { + Utf8 charSequence659; + Object oldString659 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(659); + if (oldString659 instanceof Utf8) { + charSequence659 = (decoder).readString(((Utf8) oldString659)); + } else { + charSequence659 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(659, charSequence659); + } else { + throw new RuntimeException(("Illegal union index for 'F659': "+ unionIndex659)); + } + } + int unionIndex660 = (decoder.readIndex()); + if (unionIndex660 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(660, null); + } else { + if (unionIndex660 == 1) { + Utf8 charSequence660; + Object oldString660 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(660); + if (oldString660 instanceof Utf8) { + charSequence660 = (decoder).readString(((Utf8) oldString660)); + } else { + charSequence660 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(660, charSequence660); + } else { + throw new RuntimeException(("Illegal union index for 'F660': "+ unionIndex660)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex661 = (decoder.readIndex()); + if (unionIndex661 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(661, null); + } else { + if (unionIndex661 == 1) { + Utf8 charSequence661; + Object oldString661 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(661); + if (oldString661 instanceof Utf8) { + charSequence661 = (decoder).readString(((Utf8) oldString661)); + } else { + charSequence661 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(661, charSequence661); + } else { + throw new RuntimeException(("Illegal union index for 'F661': "+ unionIndex661)); + } + } + int unionIndex662 = (decoder.readIndex()); + if (unionIndex662 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(662, null); + } else { + if (unionIndex662 == 1) { + Utf8 charSequence662; + Object oldString662 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(662); + if (oldString662 instanceof Utf8) { + charSequence662 = (decoder).readString(((Utf8) oldString662)); + } else { + charSequence662 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(662, charSequence662); + } else { + throw new RuntimeException(("Illegal union index for 'F662': "+ unionIndex662)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex663 = (decoder.readIndex()); + if (unionIndex663 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(663, null); + } else { + if (unionIndex663 == 1) { + Utf8 charSequence663; + Object oldString663 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(663); + if (oldString663 instanceof Utf8) { + charSequence663 = (decoder).readString(((Utf8) oldString663)); + } else { + charSequence663 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(663, charSequence663); + } else { + throw new RuntimeException(("Illegal union index for 'F663': "+ unionIndex663)); + } + } + int unionIndex664 = (decoder.readIndex()); + if (unionIndex664 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(664, null); + } else { + if (unionIndex664 == 1) { + Utf8 charSequence664; + Object oldString664 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(664); + if (oldString664 instanceof Utf8) { + charSequence664 = (decoder).readString(((Utf8) oldString664)); + } else { + charSequence664 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(664, charSequence664); + } else { + throw new RuntimeException(("Illegal union index for 'F664': "+ unionIndex664)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex665 = (decoder.readIndex()); + if (unionIndex665 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(665, null); + } else { + if (unionIndex665 == 1) { + Utf8 charSequence665; + Object oldString665 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(665); + if (oldString665 instanceof Utf8) { + charSequence665 = (decoder).readString(((Utf8) oldString665)); + } else { + charSequence665 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(665, charSequence665); + } else { + throw new RuntimeException(("Illegal union index for 'F665': "+ unionIndex665)); + } + } + int unionIndex666 = (decoder.readIndex()); + if (unionIndex666 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(666, null); + } else { + if (unionIndex666 == 1) { + Utf8 charSequence666; + Object oldString666 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(666); + if (oldString666 instanceof Utf8) { + charSequence666 = (decoder).readString(((Utf8) oldString666)); + } else { + charSequence666 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(666, charSequence666); + } else { + throw new RuntimeException(("Illegal union index for 'F666': "+ unionIndex666)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex667 = (decoder.readIndex()); + if (unionIndex667 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(667, null); + } else { + if (unionIndex667 == 1) { + Utf8 charSequence667; + Object oldString667 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(667); + if (oldString667 instanceof Utf8) { + charSequence667 = (decoder).readString(((Utf8) oldString667)); + } else { + charSequence667 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(667, charSequence667); + } else { + throw new RuntimeException(("Illegal union index for 'F667': "+ unionIndex667)); + } + } + int unionIndex668 = (decoder.readIndex()); + if (unionIndex668 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(668, null); + } else { + if (unionIndex668 == 1) { + Utf8 charSequence668; + Object oldString668 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(668); + if (oldString668 instanceof Utf8) { + charSequence668 = (decoder).readString(((Utf8) oldString668)); + } else { + charSequence668 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(668, charSequence668); + } else { + throw new RuntimeException(("Illegal union index for 'F668': "+ unionIndex668)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex669 = (decoder.readIndex()); + if (unionIndex669 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(669, null); + } else { + if (unionIndex669 == 1) { + Utf8 charSequence669; + Object oldString669 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(669); + if (oldString669 instanceof Utf8) { + charSequence669 = (decoder).readString(((Utf8) oldString669)); + } else { + charSequence669 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(669, charSequence669); + } else { + throw new RuntimeException(("Illegal union index for 'F669': "+ unionIndex669)); + } + } + int unionIndex670 = (decoder.readIndex()); + if (unionIndex670 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(670, null); + } else { + if (unionIndex670 == 1) { + Utf8 charSequence670; + Object oldString670 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(670); + if (oldString670 instanceof Utf8) { + charSequence670 = (decoder).readString(((Utf8) oldString670)); + } else { + charSequence670 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(670, charSequence670); + } else { + throw new RuntimeException(("Illegal union index for 'F670': "+ unionIndex670)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex671 = (decoder.readIndex()); + if (unionIndex671 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(671, null); + } else { + if (unionIndex671 == 1) { + Utf8 charSequence671; + Object oldString671 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(671); + if (oldString671 instanceof Utf8) { + charSequence671 = (decoder).readString(((Utf8) oldString671)); + } else { + charSequence671 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(671, charSequence671); + } else { + throw new RuntimeException(("Illegal union index for 'F671': "+ unionIndex671)); + } + } + int unionIndex672 = (decoder.readIndex()); + if (unionIndex672 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(672, null); + } else { + if (unionIndex672 == 1) { + Utf8 charSequence672; + Object oldString672 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(672); + if (oldString672 instanceof Utf8) { + charSequence672 = (decoder).readString(((Utf8) oldString672)); + } else { + charSequence672 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(672, charSequence672); + } else { + throw new RuntimeException(("Illegal union index for 'F672': "+ unionIndex672)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex673 = (decoder.readIndex()); + if (unionIndex673 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(673, null); + } else { + if (unionIndex673 == 1) { + Utf8 charSequence673; + Object oldString673 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(673); + if (oldString673 instanceof Utf8) { + charSequence673 = (decoder).readString(((Utf8) oldString673)); + } else { + charSequence673 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(673, charSequence673); + } else { + throw new RuntimeException(("Illegal union index for 'F673': "+ unionIndex673)); + } + } + int unionIndex674 = (decoder.readIndex()); + if (unionIndex674 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(674, null); + } else { + if (unionIndex674 == 1) { + Utf8 charSequence674; + Object oldString674 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(674); + if (oldString674 instanceof Utf8) { + charSequence674 = (decoder).readString(((Utf8) oldString674)); + } else { + charSequence674 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(674, charSequence674); + } else { + throw new RuntimeException(("Illegal union index for 'F674': "+ unionIndex674)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex675 = (decoder.readIndex()); + if (unionIndex675 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(675, null); + } else { + if (unionIndex675 == 1) { + Utf8 charSequence675; + Object oldString675 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(675); + if (oldString675 instanceof Utf8) { + charSequence675 = (decoder).readString(((Utf8) oldString675)); + } else { + charSequence675 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(675, charSequence675); + } else { + throw new RuntimeException(("Illegal union index for 'F675': "+ unionIndex675)); + } + } + int unionIndex676 = (decoder.readIndex()); + if (unionIndex676 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(676, null); + } else { + if (unionIndex676 == 1) { + Utf8 charSequence676; + Object oldString676 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(676); + if (oldString676 instanceof Utf8) { + charSequence676 = (decoder).readString(((Utf8) oldString676)); + } else { + charSequence676 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(676, charSequence676); + } else { + throw new RuntimeException(("Illegal union index for 'F676': "+ unionIndex676)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex677 = (decoder.readIndex()); + if (unionIndex677 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(677, null); + } else { + if (unionIndex677 == 1) { + Utf8 charSequence677; + Object oldString677 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(677); + if (oldString677 instanceof Utf8) { + charSequence677 = (decoder).readString(((Utf8) oldString677)); + } else { + charSequence677 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(677, charSequence677); + } else { + throw new RuntimeException(("Illegal union index for 'F677': "+ unionIndex677)); + } + } + int unionIndex678 = (decoder.readIndex()); + if (unionIndex678 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(678, null); + } else { + if (unionIndex678 == 1) { + Utf8 charSequence678; + Object oldString678 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(678); + if (oldString678 instanceof Utf8) { + charSequence678 = (decoder).readString(((Utf8) oldString678)); + } else { + charSequence678 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(678, charSequence678); + } else { + throw new RuntimeException(("Illegal union index for 'F678': "+ unionIndex678)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex679 = (decoder.readIndex()); + if (unionIndex679 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(679, null); + } else { + if (unionIndex679 == 1) { + Utf8 charSequence679; + Object oldString679 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(679); + if (oldString679 instanceof Utf8) { + charSequence679 = (decoder).readString(((Utf8) oldString679)); + } else { + charSequence679 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(679, charSequence679); + } else { + throw new RuntimeException(("Illegal union index for 'F679': "+ unionIndex679)); + } + } + int unionIndex680 = (decoder.readIndex()); + if (unionIndex680 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(680, null); + } else { + if (unionIndex680 == 1) { + Utf8 charSequence680; + Object oldString680 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(680); + if (oldString680 instanceof Utf8) { + charSequence680 = (decoder).readString(((Utf8) oldString680)); + } else { + charSequence680 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(680, charSequence680); + } else { + throw new RuntimeException(("Illegal union index for 'F680': "+ unionIndex680)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex681 = (decoder.readIndex()); + if (unionIndex681 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(681, null); + } else { + if (unionIndex681 == 1) { + Utf8 charSequence681; + Object oldString681 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(681); + if (oldString681 instanceof Utf8) { + charSequence681 = (decoder).readString(((Utf8) oldString681)); + } else { + charSequence681 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(681, charSequence681); + } else { + throw new RuntimeException(("Illegal union index for 'F681': "+ unionIndex681)); + } + } + int unionIndex682 = (decoder.readIndex()); + if (unionIndex682 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(682, null); + } else { + if (unionIndex682 == 1) { + Utf8 charSequence682; + Object oldString682 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(682); + if (oldString682 instanceof Utf8) { + charSequence682 = (decoder).readString(((Utf8) oldString682)); + } else { + charSequence682 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(682, charSequence682); + } else { + throw new RuntimeException(("Illegal union index for 'F682': "+ unionIndex682)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex683 = (decoder.readIndex()); + if (unionIndex683 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(683, null); + } else { + if (unionIndex683 == 1) { + Utf8 charSequence683; + Object oldString683 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(683); + if (oldString683 instanceof Utf8) { + charSequence683 = (decoder).readString(((Utf8) oldString683)); + } else { + charSequence683 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(683, charSequence683); + } else { + throw new RuntimeException(("Illegal union index for 'F683': "+ unionIndex683)); + } + } + int unionIndex684 = (decoder.readIndex()); + if (unionIndex684 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(684, null); + } else { + if (unionIndex684 == 1) { + Utf8 charSequence684; + Object oldString684 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(684); + if (oldString684 instanceof Utf8) { + charSequence684 = (decoder).readString(((Utf8) oldString684)); + } else { + charSequence684 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(684, charSequence684); + } else { + throw new RuntimeException(("Illegal union index for 'F684': "+ unionIndex684)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex685 = (decoder.readIndex()); + if (unionIndex685 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(685, null); + } else { + if (unionIndex685 == 1) { + Utf8 charSequence685; + Object oldString685 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(685); + if (oldString685 instanceof Utf8) { + charSequence685 = (decoder).readString(((Utf8) oldString685)); + } else { + charSequence685 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(685, charSequence685); + } else { + throw new RuntimeException(("Illegal union index for 'F685': "+ unionIndex685)); + } + } + int unionIndex686 = (decoder.readIndex()); + if (unionIndex686 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(686, null); + } else { + if (unionIndex686 == 1) { + Utf8 charSequence686; + Object oldString686 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(686); + if (oldString686 instanceof Utf8) { + charSequence686 = (decoder).readString(((Utf8) oldString686)); + } else { + charSequence686 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(686, charSequence686); + } else { + throw new RuntimeException(("Illegal union index for 'F686': "+ unionIndex686)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex687 = (decoder.readIndex()); + if (unionIndex687 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(687, null); + } else { + if (unionIndex687 == 1) { + Utf8 charSequence687; + Object oldString687 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(687); + if (oldString687 instanceof Utf8) { + charSequence687 = (decoder).readString(((Utf8) oldString687)); + } else { + charSequence687 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(687, charSequence687); + } else { + throw new RuntimeException(("Illegal union index for 'F687': "+ unionIndex687)); + } + } + int unionIndex688 = (decoder.readIndex()); + if (unionIndex688 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(688, null); + } else { + if (unionIndex688 == 1) { + Utf8 charSequence688; + Object oldString688 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(688); + if (oldString688 instanceof Utf8) { + charSequence688 = (decoder).readString(((Utf8) oldString688)); + } else { + charSequence688 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(688, charSequence688); + } else { + throw new RuntimeException(("Illegal union index for 'F688': "+ unionIndex688)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex689 = (decoder.readIndex()); + if (unionIndex689 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(689, null); + } else { + if (unionIndex689 == 1) { + Utf8 charSequence689; + Object oldString689 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(689); + if (oldString689 instanceof Utf8) { + charSequence689 = (decoder).readString(((Utf8) oldString689)); + } else { + charSequence689 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(689, charSequence689); + } else { + throw new RuntimeException(("Illegal union index for 'F689': "+ unionIndex689)); + } + } + int unionIndex690 = (decoder.readIndex()); + if (unionIndex690 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(690, null); + } else { + if (unionIndex690 == 1) { + Utf8 charSequence690; + Object oldString690 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(690); + if (oldString690 instanceof Utf8) { + charSequence690 = (decoder).readString(((Utf8) oldString690)); + } else { + charSequence690 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(690, charSequence690); + } else { + throw new RuntimeException(("Illegal union index for 'F690': "+ unionIndex690)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex691 = (decoder.readIndex()); + if (unionIndex691 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(691, null); + } else { + if (unionIndex691 == 1) { + Utf8 charSequence691; + Object oldString691 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(691); + if (oldString691 instanceof Utf8) { + charSequence691 = (decoder).readString(((Utf8) oldString691)); + } else { + charSequence691 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(691, charSequence691); + } else { + throw new RuntimeException(("Illegal union index for 'F691': "+ unionIndex691)); + } + } + int unionIndex692 = (decoder.readIndex()); + if (unionIndex692 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(692, null); + } else { + if (unionIndex692 == 1) { + Utf8 charSequence692; + Object oldString692 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(692); + if (oldString692 instanceof Utf8) { + charSequence692 = (decoder).readString(((Utf8) oldString692)); + } else { + charSequence692 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(692, charSequence692); + } else { + throw new RuntimeException(("Illegal union index for 'F692': "+ unionIndex692)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex693 = (decoder.readIndex()); + if (unionIndex693 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(693, null); + } else { + if (unionIndex693 == 1) { + Utf8 charSequence693; + Object oldString693 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(693); + if (oldString693 instanceof Utf8) { + charSequence693 = (decoder).readString(((Utf8) oldString693)); + } else { + charSequence693 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(693, charSequence693); + } else { + throw new RuntimeException(("Illegal union index for 'F693': "+ unionIndex693)); + } + } + int unionIndex694 = (decoder.readIndex()); + if (unionIndex694 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(694, null); + } else { + if (unionIndex694 == 1) { + Utf8 charSequence694; + Object oldString694 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(694); + if (oldString694 instanceof Utf8) { + charSequence694 = (decoder).readString(((Utf8) oldString694)); + } else { + charSequence694 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(694, charSequence694); + } else { + throw new RuntimeException(("Illegal union index for 'F694': "+ unionIndex694)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex695 = (decoder.readIndex()); + if (unionIndex695 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(695, null); + } else { + if (unionIndex695 == 1) { + Utf8 charSequence695; + Object oldString695 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(695); + if (oldString695 instanceof Utf8) { + charSequence695 = (decoder).readString(((Utf8) oldString695)); + } else { + charSequence695 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(695, charSequence695); + } else { + throw new RuntimeException(("Illegal union index for 'F695': "+ unionIndex695)); + } + } + int unionIndex696 = (decoder.readIndex()); + if (unionIndex696 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(696, null); + } else { + if (unionIndex696 == 1) { + Utf8 charSequence696; + Object oldString696 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(696); + if (oldString696 instanceof Utf8) { + charSequence696 = (decoder).readString(((Utf8) oldString696)); + } else { + charSequence696 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(696, charSequence696); + } else { + throw new RuntimeException(("Illegal union index for 'F696': "+ unionIndex696)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex697 = (decoder.readIndex()); + if (unionIndex697 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(697, null); + } else { + if (unionIndex697 == 1) { + Utf8 charSequence697; + Object oldString697 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(697); + if (oldString697 instanceof Utf8) { + charSequence697 = (decoder).readString(((Utf8) oldString697)); + } else { + charSequence697 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(697, charSequence697); + } else { + throw new RuntimeException(("Illegal union index for 'F697': "+ unionIndex697)); + } + } + int unionIndex698 = (decoder.readIndex()); + if (unionIndex698 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(698, null); + } else { + if (unionIndex698 == 1) { + Utf8 charSequence698; + Object oldString698 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(698); + if (oldString698 instanceof Utf8) { + charSequence698 = (decoder).readString(((Utf8) oldString698)); + } else { + charSequence698 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(698, charSequence698); + } else { + throw new RuntimeException(("Illegal union index for 'F698': "+ unionIndex698)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex699 = (decoder.readIndex()); + if (unionIndex699 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(699, null); + } else { + if (unionIndex699 == 1) { + Utf8 charSequence699; + Object oldString699 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(699); + if (oldString699 instanceof Utf8) { + charSequence699 = (decoder).readString(((Utf8) oldString699)); + } else { + charSequence699 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(699, charSequence699); + } else { + throw new RuntimeException(("Illegal union index for 'F699': "+ unionIndex699)); + } + } + int unionIndex700 = (decoder.readIndex()); + if (unionIndex700 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(700, null); + } else { + if (unionIndex700 == 1) { + Utf8 charSequence700; + Object oldString700 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(700); + if (oldString700 instanceof Utf8) { + charSequence700 = (decoder).readString(((Utf8) oldString700)); + } else { + charSequence700 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(700, charSequence700); + } else { + throw new RuntimeException(("Illegal union index for 'F700': "+ unionIndex700)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex701 = (decoder.readIndex()); + if (unionIndex701 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(701, null); + } else { + if (unionIndex701 == 1) { + Utf8 charSequence701; + Object oldString701 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(701); + if (oldString701 instanceof Utf8) { + charSequence701 = (decoder).readString(((Utf8) oldString701)); + } else { + charSequence701 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(701, charSequence701); + } else { + throw new RuntimeException(("Illegal union index for 'F701': "+ unionIndex701)); + } + } + int unionIndex702 = (decoder.readIndex()); + if (unionIndex702 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(702, null); + } else { + if (unionIndex702 == 1) { + Utf8 charSequence702; + Object oldString702 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(702); + if (oldString702 instanceof Utf8) { + charSequence702 = (decoder).readString(((Utf8) oldString702)); + } else { + charSequence702 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(702, charSequence702); + } else { + throw new RuntimeException(("Illegal union index for 'F702': "+ unionIndex702)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex703 = (decoder.readIndex()); + if (unionIndex703 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(703, null); + } else { + if (unionIndex703 == 1) { + Utf8 charSequence703; + Object oldString703 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(703); + if (oldString703 instanceof Utf8) { + charSequence703 = (decoder).readString(((Utf8) oldString703)); + } else { + charSequence703 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(703, charSequence703); + } else { + throw new RuntimeException(("Illegal union index for 'F703': "+ unionIndex703)); + } + } + int unionIndex704 = (decoder.readIndex()); + if (unionIndex704 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(704, null); + } else { + if (unionIndex704 == 1) { + Utf8 charSequence704; + Object oldString704 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(704); + if (oldString704 instanceof Utf8) { + charSequence704 = (decoder).readString(((Utf8) oldString704)); + } else { + charSequence704 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(704, charSequence704); + } else { + throw new RuntimeException(("Illegal union index for 'F704': "+ unionIndex704)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex705 = (decoder.readIndex()); + if (unionIndex705 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(705, null); + } else { + if (unionIndex705 == 1) { + Utf8 charSequence705; + Object oldString705 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(705); + if (oldString705 instanceof Utf8) { + charSequence705 = (decoder).readString(((Utf8) oldString705)); + } else { + charSequence705 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(705, charSequence705); + } else { + throw new RuntimeException(("Illegal union index for 'F705': "+ unionIndex705)); + } + } + int unionIndex706 = (decoder.readIndex()); + if (unionIndex706 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(706, null); + } else { + if (unionIndex706 == 1) { + Utf8 charSequence706; + Object oldString706 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(706); + if (oldString706 instanceof Utf8) { + charSequence706 = (decoder).readString(((Utf8) oldString706)); + } else { + charSequence706 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(706, charSequence706); + } else { + throw new RuntimeException(("Illegal union index for 'F706': "+ unionIndex706)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex707 = (decoder.readIndex()); + if (unionIndex707 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(707, null); + } else { + if (unionIndex707 == 1) { + Utf8 charSequence707; + Object oldString707 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(707); + if (oldString707 instanceof Utf8) { + charSequence707 = (decoder).readString(((Utf8) oldString707)); + } else { + charSequence707 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(707, charSequence707); + } else { + throw new RuntimeException(("Illegal union index for 'F707': "+ unionIndex707)); + } + } + int unionIndex708 = (decoder.readIndex()); + if (unionIndex708 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(708, null); + } else { + if (unionIndex708 == 1) { + Utf8 charSequence708; + Object oldString708 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(708); + if (oldString708 instanceof Utf8) { + charSequence708 = (decoder).readString(((Utf8) oldString708)); + } else { + charSequence708 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(708, charSequence708); + } else { + throw new RuntimeException(("Illegal union index for 'F708': "+ unionIndex708)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex709 = (decoder.readIndex()); + if (unionIndex709 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(709, null); + } else { + if (unionIndex709 == 1) { + Utf8 charSequence709; + Object oldString709 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(709); + if (oldString709 instanceof Utf8) { + charSequence709 = (decoder).readString(((Utf8) oldString709)); + } else { + charSequence709 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(709, charSequence709); + } else { + throw new RuntimeException(("Illegal union index for 'F709': "+ unionIndex709)); + } + } + int unionIndex710 = (decoder.readIndex()); + if (unionIndex710 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(710, null); + } else { + if (unionIndex710 == 1) { + Utf8 charSequence710; + Object oldString710 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(710); + if (oldString710 instanceof Utf8) { + charSequence710 = (decoder).readString(((Utf8) oldString710)); + } else { + charSequence710 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(710, charSequence710); + } else { + throw new RuntimeException(("Illegal union index for 'F710': "+ unionIndex710)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex711 = (decoder.readIndex()); + if (unionIndex711 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(711, null); + } else { + if (unionIndex711 == 1) { + Utf8 charSequence711; + Object oldString711 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(711); + if (oldString711 instanceof Utf8) { + charSequence711 = (decoder).readString(((Utf8) oldString711)); + } else { + charSequence711 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(711, charSequence711); + } else { + throw new RuntimeException(("Illegal union index for 'F711': "+ unionIndex711)); + } + } + int unionIndex712 = (decoder.readIndex()); + if (unionIndex712 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(712, null); + } else { + if (unionIndex712 == 1) { + Utf8 charSequence712; + Object oldString712 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(712); + if (oldString712 instanceof Utf8) { + charSequence712 = (decoder).readString(((Utf8) oldString712)); + } else { + charSequence712 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(712, charSequence712); + } else { + throw new RuntimeException(("Illegal union index for 'F712': "+ unionIndex712)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex713 = (decoder.readIndex()); + if (unionIndex713 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(713, null); + } else { + if (unionIndex713 == 1) { + Utf8 charSequence713; + Object oldString713 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(713); + if (oldString713 instanceof Utf8) { + charSequence713 = (decoder).readString(((Utf8) oldString713)); + } else { + charSequence713 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(713, charSequence713); + } else { + throw new RuntimeException(("Illegal union index for 'F713': "+ unionIndex713)); + } + } + int unionIndex714 = (decoder.readIndex()); + if (unionIndex714 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(714, null); + } else { + if (unionIndex714 == 1) { + Utf8 charSequence714; + Object oldString714 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(714); + if (oldString714 instanceof Utf8) { + charSequence714 = (decoder).readString(((Utf8) oldString714)); + } else { + charSequence714 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(714, charSequence714); + } else { + throw new RuntimeException(("Illegal union index for 'F714': "+ unionIndex714)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex715 = (decoder.readIndex()); + if (unionIndex715 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(715, null); + } else { + if (unionIndex715 == 1) { + Utf8 charSequence715; + Object oldString715 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(715); + if (oldString715 instanceof Utf8) { + charSequence715 = (decoder).readString(((Utf8) oldString715)); + } else { + charSequence715 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(715, charSequence715); + } else { + throw new RuntimeException(("Illegal union index for 'F715': "+ unionIndex715)); + } + } + int unionIndex716 = (decoder.readIndex()); + if (unionIndex716 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(716, null); + } else { + if (unionIndex716 == 1) { + Utf8 charSequence716; + Object oldString716 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(716); + if (oldString716 instanceof Utf8) { + charSequence716 = (decoder).readString(((Utf8) oldString716)); + } else { + charSequence716 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(716, charSequence716); + } else { + throw new RuntimeException(("Illegal union index for 'F716': "+ unionIndex716)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex717 = (decoder.readIndex()); + if (unionIndex717 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(717, null); + } else { + if (unionIndex717 == 1) { + Utf8 charSequence717; + Object oldString717 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(717); + if (oldString717 instanceof Utf8) { + charSequence717 = (decoder).readString(((Utf8) oldString717)); + } else { + charSequence717 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(717, charSequence717); + } else { + throw new RuntimeException(("Illegal union index for 'F717': "+ unionIndex717)); + } + } + int unionIndex718 = (decoder.readIndex()); + if (unionIndex718 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(718, null); + } else { + if (unionIndex718 == 1) { + Utf8 charSequence718; + Object oldString718 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(718); + if (oldString718 instanceof Utf8) { + charSequence718 = (decoder).readString(((Utf8) oldString718)); + } else { + charSequence718 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(718, charSequence718); + } else { + throw new RuntimeException(("Illegal union index for 'F718': "+ unionIndex718)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex719 = (decoder.readIndex()); + if (unionIndex719 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(719, null); + } else { + if (unionIndex719 == 1) { + Utf8 charSequence719; + Object oldString719 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(719); + if (oldString719 instanceof Utf8) { + charSequence719 = (decoder).readString(((Utf8) oldString719)); + } else { + charSequence719 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(719, charSequence719); + } else { + throw new RuntimeException(("Illegal union index for 'F719': "+ unionIndex719)); + } + } + int unionIndex720 = (decoder.readIndex()); + if (unionIndex720 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(720, null); + } else { + if (unionIndex720 == 1) { + Utf8 charSequence720; + Object oldString720 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(720); + if (oldString720 instanceof Utf8) { + charSequence720 = (decoder).readString(((Utf8) oldString720)); + } else { + charSequence720 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(720, charSequence720); + } else { + throw new RuntimeException(("Illegal union index for 'F720': "+ unionIndex720)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex721 = (decoder.readIndex()); + if (unionIndex721 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(721, null); + } else { + if (unionIndex721 == 1) { + Utf8 charSequence721; + Object oldString721 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(721); + if (oldString721 instanceof Utf8) { + charSequence721 = (decoder).readString(((Utf8) oldString721)); + } else { + charSequence721 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(721, charSequence721); + } else { + throw new RuntimeException(("Illegal union index for 'F721': "+ unionIndex721)); + } + } + int unionIndex722 = (decoder.readIndex()); + if (unionIndex722 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(722, null); + } else { + if (unionIndex722 == 1) { + Utf8 charSequence722; + Object oldString722 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(722); + if (oldString722 instanceof Utf8) { + charSequence722 = (decoder).readString(((Utf8) oldString722)); + } else { + charSequence722 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(722, charSequence722); + } else { + throw new RuntimeException(("Illegal union index for 'F722': "+ unionIndex722)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex723 = (decoder.readIndex()); + if (unionIndex723 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(723, null); + } else { + if (unionIndex723 == 1) { + Utf8 charSequence723; + Object oldString723 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(723); + if (oldString723 instanceof Utf8) { + charSequence723 = (decoder).readString(((Utf8) oldString723)); + } else { + charSequence723 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(723, charSequence723); + } else { + throw new RuntimeException(("Illegal union index for 'F723': "+ unionIndex723)); + } + } + int unionIndex724 = (decoder.readIndex()); + if (unionIndex724 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(724, null); + } else { + if (unionIndex724 == 1) { + Utf8 charSequence724; + Object oldString724 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(724); + if (oldString724 instanceof Utf8) { + charSequence724 = (decoder).readString(((Utf8) oldString724)); + } else { + charSequence724 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(724, charSequence724); + } else { + throw new RuntimeException(("Illegal union index for 'F724': "+ unionIndex724)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex725 = (decoder.readIndex()); + if (unionIndex725 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(725, null); + } else { + if (unionIndex725 == 1) { + Utf8 charSequence725; + Object oldString725 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(725); + if (oldString725 instanceof Utf8) { + charSequence725 = (decoder).readString(((Utf8) oldString725)); + } else { + charSequence725 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(725, charSequence725); + } else { + throw new RuntimeException(("Illegal union index for 'F725': "+ unionIndex725)); + } + } + int unionIndex726 = (decoder.readIndex()); + if (unionIndex726 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(726, null); + } else { + if (unionIndex726 == 1) { + Utf8 charSequence726; + Object oldString726 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(726); + if (oldString726 instanceof Utf8) { + charSequence726 = (decoder).readString(((Utf8) oldString726)); + } else { + charSequence726 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(726, charSequence726); + } else { + throw new RuntimeException(("Illegal union index for 'F726': "+ unionIndex726)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex727 = (decoder.readIndex()); + if (unionIndex727 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(727, null); + } else { + if (unionIndex727 == 1) { + Utf8 charSequence727; + Object oldString727 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(727); + if (oldString727 instanceof Utf8) { + charSequence727 = (decoder).readString(((Utf8) oldString727)); + } else { + charSequence727 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(727, charSequence727); + } else { + throw new RuntimeException(("Illegal union index for 'F727': "+ unionIndex727)); + } + } + int unionIndex728 = (decoder.readIndex()); + if (unionIndex728 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(728, null); + } else { + if (unionIndex728 == 1) { + Utf8 charSequence728; + Object oldString728 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(728); + if (oldString728 instanceof Utf8) { + charSequence728 = (decoder).readString(((Utf8) oldString728)); + } else { + charSequence728 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(728, charSequence728); + } else { + throw new RuntimeException(("Illegal union index for 'F728': "+ unionIndex728)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex729 = (decoder.readIndex()); + if (unionIndex729 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(729, null); + } else { + if (unionIndex729 == 1) { + Utf8 charSequence729; + Object oldString729 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(729); + if (oldString729 instanceof Utf8) { + charSequence729 = (decoder).readString(((Utf8) oldString729)); + } else { + charSequence729 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(729, charSequence729); + } else { + throw new RuntimeException(("Illegal union index for 'F729': "+ unionIndex729)); + } + } + int unionIndex730 = (decoder.readIndex()); + if (unionIndex730 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(730, null); + } else { + if (unionIndex730 == 1) { + Utf8 charSequence730; + Object oldString730 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(730); + if (oldString730 instanceof Utf8) { + charSequence730 = (decoder).readString(((Utf8) oldString730)); + } else { + charSequence730 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(730, charSequence730); + } else { + throw new RuntimeException(("Illegal union index for 'F730': "+ unionIndex730)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex731 = (decoder.readIndex()); + if (unionIndex731 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(731, null); + } else { + if (unionIndex731 == 1) { + Utf8 charSequence731; + Object oldString731 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(731); + if (oldString731 instanceof Utf8) { + charSequence731 = (decoder).readString(((Utf8) oldString731)); + } else { + charSequence731 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(731, charSequence731); + } else { + throw new RuntimeException(("Illegal union index for 'F731': "+ unionIndex731)); + } + } + int unionIndex732 = (decoder.readIndex()); + if (unionIndex732 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(732, null); + } else { + if (unionIndex732 == 1) { + Utf8 charSequence732; + Object oldString732 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(732); + if (oldString732 instanceof Utf8) { + charSequence732 = (decoder).readString(((Utf8) oldString732)); + } else { + charSequence732 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(732, charSequence732); + } else { + throw new RuntimeException(("Illegal union index for 'F732': "+ unionIndex732)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex733 = (decoder.readIndex()); + if (unionIndex733 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(733, null); + } else { + if (unionIndex733 == 1) { + Utf8 charSequence733; + Object oldString733 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(733); + if (oldString733 instanceof Utf8) { + charSequence733 = (decoder).readString(((Utf8) oldString733)); + } else { + charSequence733 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(733, charSequence733); + } else { + throw new RuntimeException(("Illegal union index for 'F733': "+ unionIndex733)); + } + } + int unionIndex734 = (decoder.readIndex()); + if (unionIndex734 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(734, null); + } else { + if (unionIndex734 == 1) { + Utf8 charSequence734; + Object oldString734 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(734); + if (oldString734 instanceof Utf8) { + charSequence734 = (decoder).readString(((Utf8) oldString734)); + } else { + charSequence734 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(734, charSequence734); + } else { + throw new RuntimeException(("Illegal union index for 'F734': "+ unionIndex734)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex735 = (decoder.readIndex()); + if (unionIndex735 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(735, null); + } else { + if (unionIndex735 == 1) { + Utf8 charSequence735; + Object oldString735 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(735); + if (oldString735 instanceof Utf8) { + charSequence735 = (decoder).readString(((Utf8) oldString735)); + } else { + charSequence735 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(735, charSequence735); + } else { + throw new RuntimeException(("Illegal union index for 'F735': "+ unionIndex735)); + } + } + int unionIndex736 = (decoder.readIndex()); + if (unionIndex736 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(736, null); + } else { + if (unionIndex736 == 1) { + Utf8 charSequence736; + Object oldString736 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(736); + if (oldString736 instanceof Utf8) { + charSequence736 = (decoder).readString(((Utf8) oldString736)); + } else { + charSequence736 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(736, charSequence736); + } else { + throw new RuntimeException(("Illegal union index for 'F736': "+ unionIndex736)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex737 = (decoder.readIndex()); + if (unionIndex737 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(737, null); + } else { + if (unionIndex737 == 1) { + Utf8 charSequence737; + Object oldString737 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(737); + if (oldString737 instanceof Utf8) { + charSequence737 = (decoder).readString(((Utf8) oldString737)); + } else { + charSequence737 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(737, charSequence737); + } else { + throw new RuntimeException(("Illegal union index for 'F737': "+ unionIndex737)); + } + } + int unionIndex738 = (decoder.readIndex()); + if (unionIndex738 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(738, null); + } else { + if (unionIndex738 == 1) { + Utf8 charSequence738; + Object oldString738 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(738); + if (oldString738 instanceof Utf8) { + charSequence738 = (decoder).readString(((Utf8) oldString738)); + } else { + charSequence738 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(738, charSequence738); + } else { + throw new RuntimeException(("Illegal union index for 'F738': "+ unionIndex738)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex739 = (decoder.readIndex()); + if (unionIndex739 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(739, null); + } else { + if (unionIndex739 == 1) { + Utf8 charSequence739; + Object oldString739 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(739); + if (oldString739 instanceof Utf8) { + charSequence739 = (decoder).readString(((Utf8) oldString739)); + } else { + charSequence739 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(739, charSequence739); + } else { + throw new RuntimeException(("Illegal union index for 'F739': "+ unionIndex739)); + } + } + int unionIndex740 = (decoder.readIndex()); + if (unionIndex740 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(740, null); + } else { + if (unionIndex740 == 1) { + Utf8 charSequence740; + Object oldString740 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(740); + if (oldString740 instanceof Utf8) { + charSequence740 = (decoder).readString(((Utf8) oldString740)); + } else { + charSequence740 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(740, charSequence740); + } else { + throw new RuntimeException(("Illegal union index for 'F740': "+ unionIndex740)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex741 = (decoder.readIndex()); + if (unionIndex741 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(741, null); + } else { + if (unionIndex741 == 1) { + Utf8 charSequence741; + Object oldString741 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(741); + if (oldString741 instanceof Utf8) { + charSequence741 = (decoder).readString(((Utf8) oldString741)); + } else { + charSequence741 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(741, charSequence741); + } else { + throw new RuntimeException(("Illegal union index for 'F741': "+ unionIndex741)); + } + } + int unionIndex742 = (decoder.readIndex()); + if (unionIndex742 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(742, null); + } else { + if (unionIndex742 == 1) { + Utf8 charSequence742; + Object oldString742 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(742); + if (oldString742 instanceof Utf8) { + charSequence742 = (decoder).readString(((Utf8) oldString742)); + } else { + charSequence742 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(742, charSequence742); + } else { + throw new RuntimeException(("Illegal union index for 'F742': "+ unionIndex742)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex743 = (decoder.readIndex()); + if (unionIndex743 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(743, null); + } else { + if (unionIndex743 == 1) { + Utf8 charSequence743; + Object oldString743 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(743); + if (oldString743 instanceof Utf8) { + charSequence743 = (decoder).readString(((Utf8) oldString743)); + } else { + charSequence743 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(743, charSequence743); + } else { + throw new RuntimeException(("Illegal union index for 'F743': "+ unionIndex743)); + } + } + int unionIndex744 = (decoder.readIndex()); + if (unionIndex744 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(744, null); + } else { + if (unionIndex744 == 1) { + Utf8 charSequence744; + Object oldString744 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(744); + if (oldString744 instanceof Utf8) { + charSequence744 = (decoder).readString(((Utf8) oldString744)); + } else { + charSequence744 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(744, charSequence744); + } else { + throw new RuntimeException(("Illegal union index for 'F744': "+ unionIndex744)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex745 = (decoder.readIndex()); + if (unionIndex745 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(745, null); + } else { + if (unionIndex745 == 1) { + Utf8 charSequence745; + Object oldString745 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(745); + if (oldString745 instanceof Utf8) { + charSequence745 = (decoder).readString(((Utf8) oldString745)); + } else { + charSequence745 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(745, charSequence745); + } else { + throw new RuntimeException(("Illegal union index for 'F745': "+ unionIndex745)); + } + } + int unionIndex746 = (decoder.readIndex()); + if (unionIndex746 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(746, null); + } else { + if (unionIndex746 == 1) { + Utf8 charSequence746; + Object oldString746 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(746); + if (oldString746 instanceof Utf8) { + charSequence746 = (decoder).readString(((Utf8) oldString746)); + } else { + charSequence746 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(746, charSequence746); + } else { + throw new RuntimeException(("Illegal union index for 'F746': "+ unionIndex746)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex747 = (decoder.readIndex()); + if (unionIndex747 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(747, null); + } else { + if (unionIndex747 == 1) { + Utf8 charSequence747; + Object oldString747 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(747); + if (oldString747 instanceof Utf8) { + charSequence747 = (decoder).readString(((Utf8) oldString747)); + } else { + charSequence747 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(747, charSequence747); + } else { + throw new RuntimeException(("Illegal union index for 'F747': "+ unionIndex747)); + } + } + int unionIndex748 = (decoder.readIndex()); + if (unionIndex748 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(748, null); + } else { + if (unionIndex748 == 1) { + Utf8 charSequence748; + Object oldString748 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(748); + if (oldString748 instanceof Utf8) { + charSequence748 = (decoder).readString(((Utf8) oldString748)); + } else { + charSequence748 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(748, charSequence748); + } else { + throw new RuntimeException(("Illegal union index for 'F748': "+ unionIndex748)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex749 = (decoder.readIndex()); + if (unionIndex749 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(749, null); + } else { + if (unionIndex749 == 1) { + Utf8 charSequence749; + Object oldString749 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(749); + if (oldString749 instanceof Utf8) { + charSequence749 = (decoder).readString(((Utf8) oldString749)); + } else { + charSequence749 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(749, charSequence749); + } else { + throw new RuntimeException(("Illegal union index for 'F749': "+ unionIndex749)); + } + } + int unionIndex750 = (decoder.readIndex()); + if (unionIndex750 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(750, null); + } else { + if (unionIndex750 == 1) { + Utf8 charSequence750; + Object oldString750 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(750); + if (oldString750 instanceof Utf8) { + charSequence750 = (decoder).readString(((Utf8) oldString750)); + } else { + charSequence750 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(750, charSequence750); + } else { + throw new RuntimeException(("Illegal union index for 'F750': "+ unionIndex750)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex751 = (decoder.readIndex()); + if (unionIndex751 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(751, null); + } else { + if (unionIndex751 == 1) { + Utf8 charSequence751; + Object oldString751 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(751); + if (oldString751 instanceof Utf8) { + charSequence751 = (decoder).readString(((Utf8) oldString751)); + } else { + charSequence751 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(751, charSequence751); + } else { + throw new RuntimeException(("Illegal union index for 'F751': "+ unionIndex751)); + } + } + int unionIndex752 = (decoder.readIndex()); + if (unionIndex752 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(752, null); + } else { + if (unionIndex752 == 1) { + Utf8 charSequence752; + Object oldString752 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(752); + if (oldString752 instanceof Utf8) { + charSequence752 = (decoder).readString(((Utf8) oldString752)); + } else { + charSequence752 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(752, charSequence752); + } else { + throw new RuntimeException(("Illegal union index for 'F752': "+ unionIndex752)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex753 = (decoder.readIndex()); + if (unionIndex753 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(753, null); + } else { + if (unionIndex753 == 1) { + Utf8 charSequence753; + Object oldString753 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(753); + if (oldString753 instanceof Utf8) { + charSequence753 = (decoder).readString(((Utf8) oldString753)); + } else { + charSequence753 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(753, charSequence753); + } else { + throw new RuntimeException(("Illegal union index for 'F753': "+ unionIndex753)); + } + } + int unionIndex754 = (decoder.readIndex()); + if (unionIndex754 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(754, null); + } else { + if (unionIndex754 == 1) { + Utf8 charSequence754; + Object oldString754 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(754); + if (oldString754 instanceof Utf8) { + charSequence754 = (decoder).readString(((Utf8) oldString754)); + } else { + charSequence754 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(754, charSequence754); + } else { + throw new RuntimeException(("Illegal union index for 'F754': "+ unionIndex754)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex755 = (decoder.readIndex()); + if (unionIndex755 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(755, null); + } else { + if (unionIndex755 == 1) { + Utf8 charSequence755; + Object oldString755 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(755); + if (oldString755 instanceof Utf8) { + charSequence755 = (decoder).readString(((Utf8) oldString755)); + } else { + charSequence755 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(755, charSequence755); + } else { + throw new RuntimeException(("Illegal union index for 'F755': "+ unionIndex755)); + } + } + int unionIndex756 = (decoder.readIndex()); + if (unionIndex756 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(756, null); + } else { + if (unionIndex756 == 1) { + Utf8 charSequence756; + Object oldString756 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(756); + if (oldString756 instanceof Utf8) { + charSequence756 = (decoder).readString(((Utf8) oldString756)); + } else { + charSequence756 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(756, charSequence756); + } else { + throw new RuntimeException(("Illegal union index for 'F756': "+ unionIndex756)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex757 = (decoder.readIndex()); + if (unionIndex757 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(757, null); + } else { + if (unionIndex757 == 1) { + Utf8 charSequence757; + Object oldString757 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(757); + if (oldString757 instanceof Utf8) { + charSequence757 = (decoder).readString(((Utf8) oldString757)); + } else { + charSequence757 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(757, charSequence757); + } else { + throw new RuntimeException(("Illegal union index for 'F757': "+ unionIndex757)); + } + } + int unionIndex758 = (decoder.readIndex()); + if (unionIndex758 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(758, null); + } else { + if (unionIndex758 == 1) { + Utf8 charSequence758; + Object oldString758 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(758); + if (oldString758 instanceof Utf8) { + charSequence758 = (decoder).readString(((Utf8) oldString758)); + } else { + charSequence758 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(758, charSequence758); + } else { + throw new RuntimeException(("Illegal union index for 'F758': "+ unionIndex758)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex759 = (decoder.readIndex()); + if (unionIndex759 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(759, null); + } else { + if (unionIndex759 == 1) { + Utf8 charSequence759; + Object oldString759 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(759); + if (oldString759 instanceof Utf8) { + charSequence759 = (decoder).readString(((Utf8) oldString759)); + } else { + charSequence759 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(759, charSequence759); + } else { + throw new RuntimeException(("Illegal union index for 'F759': "+ unionIndex759)); + } + } + int unionIndex760 = (decoder.readIndex()); + if (unionIndex760 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(760, null); + } else { + if (unionIndex760 == 1) { + Utf8 charSequence760; + Object oldString760 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(760); + if (oldString760 instanceof Utf8) { + charSequence760 = (decoder).readString(((Utf8) oldString760)); + } else { + charSequence760 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(760, charSequence760); + } else { + throw new RuntimeException(("Illegal union index for 'F760': "+ unionIndex760)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex761 = (decoder.readIndex()); + if (unionIndex761 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(761, null); + } else { + if (unionIndex761 == 1) { + Utf8 charSequence761; + Object oldString761 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(761); + if (oldString761 instanceof Utf8) { + charSequence761 = (decoder).readString(((Utf8) oldString761)); + } else { + charSequence761 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(761, charSequence761); + } else { + throw new RuntimeException(("Illegal union index for 'F761': "+ unionIndex761)); + } + } + int unionIndex762 = (decoder.readIndex()); + if (unionIndex762 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(762, null); + } else { + if (unionIndex762 == 1) { + Utf8 charSequence762; + Object oldString762 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(762); + if (oldString762 instanceof Utf8) { + charSequence762 = (decoder).readString(((Utf8) oldString762)); + } else { + charSequence762 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(762, charSequence762); + } else { + throw new RuntimeException(("Illegal union index for 'F762': "+ unionIndex762)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex763 = (decoder.readIndex()); + if (unionIndex763 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(763, null); + } else { + if (unionIndex763 == 1) { + Utf8 charSequence763; + Object oldString763 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(763); + if (oldString763 instanceof Utf8) { + charSequence763 = (decoder).readString(((Utf8) oldString763)); + } else { + charSequence763 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(763, charSequence763); + } else { + throw new RuntimeException(("Illegal union index for 'F763': "+ unionIndex763)); + } + } + int unionIndex764 = (decoder.readIndex()); + if (unionIndex764 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(764, null); + } else { + if (unionIndex764 == 1) { + Utf8 charSequence764; + Object oldString764 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(764); + if (oldString764 instanceof Utf8) { + charSequence764 = (decoder).readString(((Utf8) oldString764)); + } else { + charSequence764 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(764, charSequence764); + } else { + throw new RuntimeException(("Illegal union index for 'F764': "+ unionIndex764)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex765 = (decoder.readIndex()); + if (unionIndex765 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(765, null); + } else { + if (unionIndex765 == 1) { + Utf8 charSequence765; + Object oldString765 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(765); + if (oldString765 instanceof Utf8) { + charSequence765 = (decoder).readString(((Utf8) oldString765)); + } else { + charSequence765 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(765, charSequence765); + } else { + throw new RuntimeException(("Illegal union index for 'F765': "+ unionIndex765)); + } + } + int unionIndex766 = (decoder.readIndex()); + if (unionIndex766 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(766, null); + } else { + if (unionIndex766 == 1) { + Utf8 charSequence766; + Object oldString766 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(766); + if (oldString766 instanceof Utf8) { + charSequence766 = (decoder).readString(((Utf8) oldString766)); + } else { + charSequence766 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(766, charSequence766); + } else { + throw new RuntimeException(("Illegal union index for 'F766': "+ unionIndex766)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex767 = (decoder.readIndex()); + if (unionIndex767 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(767, null); + } else { + if (unionIndex767 == 1) { + Utf8 charSequence767; + Object oldString767 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(767); + if (oldString767 instanceof Utf8) { + charSequence767 = (decoder).readString(((Utf8) oldString767)); + } else { + charSequence767 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(767, charSequence767); + } else { + throw new RuntimeException(("Illegal union index for 'F767': "+ unionIndex767)); + } + } + int unionIndex768 = (decoder.readIndex()); + if (unionIndex768 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(768, null); + } else { + if (unionIndex768 == 1) { + Utf8 charSequence768; + Object oldString768 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(768); + if (oldString768 instanceof Utf8) { + charSequence768 = (decoder).readString(((Utf8) oldString768)); + } else { + charSequence768 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(768, charSequence768); + } else { + throw new RuntimeException(("Illegal union index for 'F768': "+ unionIndex768)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex769 = (decoder.readIndex()); + if (unionIndex769 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(769, null); + } else { + if (unionIndex769 == 1) { + Utf8 charSequence769; + Object oldString769 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(769); + if (oldString769 instanceof Utf8) { + charSequence769 = (decoder).readString(((Utf8) oldString769)); + } else { + charSequence769 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(769, charSequence769); + } else { + throw new RuntimeException(("Illegal union index for 'F769': "+ unionIndex769)); + } + } + int unionIndex770 = (decoder.readIndex()); + if (unionIndex770 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(770, null); + } else { + if (unionIndex770 == 1) { + Utf8 charSequence770; + Object oldString770 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(770); + if (oldString770 instanceof Utf8) { + charSequence770 = (decoder).readString(((Utf8) oldString770)); + } else { + charSequence770 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(770, charSequence770); + } else { + throw new RuntimeException(("Illegal union index for 'F770': "+ unionIndex770)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex771 = (decoder.readIndex()); + if (unionIndex771 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(771, null); + } else { + if (unionIndex771 == 1) { + Utf8 charSequence771; + Object oldString771 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(771); + if (oldString771 instanceof Utf8) { + charSequence771 = (decoder).readString(((Utf8) oldString771)); + } else { + charSequence771 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(771, charSequence771); + } else { + throw new RuntimeException(("Illegal union index for 'F771': "+ unionIndex771)); + } + } + int unionIndex772 = (decoder.readIndex()); + if (unionIndex772 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(772, null); + } else { + if (unionIndex772 == 1) { + Utf8 charSequence772; + Object oldString772 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(772); + if (oldString772 instanceof Utf8) { + charSequence772 = (decoder).readString(((Utf8) oldString772)); + } else { + charSequence772 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(772, charSequence772); + } else { + throw new RuntimeException(("Illegal union index for 'F772': "+ unionIndex772)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex773 = (decoder.readIndex()); + if (unionIndex773 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(773, null); + } else { + if (unionIndex773 == 1) { + Utf8 charSequence773; + Object oldString773 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(773); + if (oldString773 instanceof Utf8) { + charSequence773 = (decoder).readString(((Utf8) oldString773)); + } else { + charSequence773 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(773, charSequence773); + } else { + throw new RuntimeException(("Illegal union index for 'F773': "+ unionIndex773)); + } + } + int unionIndex774 = (decoder.readIndex()); + if (unionIndex774 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(774, null); + } else { + if (unionIndex774 == 1) { + Utf8 charSequence774; + Object oldString774 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(774); + if (oldString774 instanceof Utf8) { + charSequence774 = (decoder).readString(((Utf8) oldString774)); + } else { + charSequence774 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(774, charSequence774); + } else { + throw new RuntimeException(("Illegal union index for 'F774': "+ unionIndex774)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex775 = (decoder.readIndex()); + if (unionIndex775 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(775, null); + } else { + if (unionIndex775 == 1) { + Utf8 charSequence775; + Object oldString775 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(775); + if (oldString775 instanceof Utf8) { + charSequence775 = (decoder).readString(((Utf8) oldString775)); + } else { + charSequence775 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(775, charSequence775); + } else { + throw new RuntimeException(("Illegal union index for 'F775': "+ unionIndex775)); + } + } + int unionIndex776 = (decoder.readIndex()); + if (unionIndex776 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(776, null); + } else { + if (unionIndex776 == 1) { + Utf8 charSequence776; + Object oldString776 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(776); + if (oldString776 instanceof Utf8) { + charSequence776 = (decoder).readString(((Utf8) oldString776)); + } else { + charSequence776 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(776, charSequence776); + } else { + throw new RuntimeException(("Illegal union index for 'F776': "+ unionIndex776)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex777 = (decoder.readIndex()); + if (unionIndex777 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(777, null); + } else { + if (unionIndex777 == 1) { + Utf8 charSequence777; + Object oldString777 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(777); + if (oldString777 instanceof Utf8) { + charSequence777 = (decoder).readString(((Utf8) oldString777)); + } else { + charSequence777 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(777, charSequence777); + } else { + throw new RuntimeException(("Illegal union index for 'F777': "+ unionIndex777)); + } + } + int unionIndex778 = (decoder.readIndex()); + if (unionIndex778 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(778, null); + } else { + if (unionIndex778 == 1) { + Utf8 charSequence778; + Object oldString778 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(778); + if (oldString778 instanceof Utf8) { + charSequence778 = (decoder).readString(((Utf8) oldString778)); + } else { + charSequence778 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(778, charSequence778); + } else { + throw new RuntimeException(("Illegal union index for 'F778': "+ unionIndex778)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex779 = (decoder.readIndex()); + if (unionIndex779 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(779, null); + } else { + if (unionIndex779 == 1) { + Utf8 charSequence779; + Object oldString779 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(779); + if (oldString779 instanceof Utf8) { + charSequence779 = (decoder).readString(((Utf8) oldString779)); + } else { + charSequence779 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(779, charSequence779); + } else { + throw new RuntimeException(("Illegal union index for 'F779': "+ unionIndex779)); + } + } + int unionIndex780 = (decoder.readIndex()); + if (unionIndex780 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(780, null); + } else { + if (unionIndex780 == 1) { + Utf8 charSequence780; + Object oldString780 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(780); + if (oldString780 instanceof Utf8) { + charSequence780 = (decoder).readString(((Utf8) oldString780)); + } else { + charSequence780 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(780, charSequence780); + } else { + throw new RuntimeException(("Illegal union index for 'F780': "+ unionIndex780)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex781 = (decoder.readIndex()); + if (unionIndex781 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(781, null); + } else { + if (unionIndex781 == 1) { + Utf8 charSequence781; + Object oldString781 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(781); + if (oldString781 instanceof Utf8) { + charSequence781 = (decoder).readString(((Utf8) oldString781)); + } else { + charSequence781 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(781, charSequence781); + } else { + throw new RuntimeException(("Illegal union index for 'F781': "+ unionIndex781)); + } + } + int unionIndex782 = (decoder.readIndex()); + if (unionIndex782 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(782, null); + } else { + if (unionIndex782 == 1) { + Utf8 charSequence782; + Object oldString782 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(782); + if (oldString782 instanceof Utf8) { + charSequence782 = (decoder).readString(((Utf8) oldString782)); + } else { + charSequence782 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(782, charSequence782); + } else { + throw new RuntimeException(("Illegal union index for 'F782': "+ unionIndex782)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex783 = (decoder.readIndex()); + if (unionIndex783 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(783, null); + } else { + if (unionIndex783 == 1) { + Utf8 charSequence783; + Object oldString783 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(783); + if (oldString783 instanceof Utf8) { + charSequence783 = (decoder).readString(((Utf8) oldString783)); + } else { + charSequence783 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(783, charSequence783); + } else { + throw new RuntimeException(("Illegal union index for 'F783': "+ unionIndex783)); + } + } + int unionIndex784 = (decoder.readIndex()); + if (unionIndex784 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(784, null); + } else { + if (unionIndex784 == 1) { + Utf8 charSequence784; + Object oldString784 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(784); + if (oldString784 instanceof Utf8) { + charSequence784 = (decoder).readString(((Utf8) oldString784)); + } else { + charSequence784 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(784, charSequence784); + } else { + throw new RuntimeException(("Illegal union index for 'F784': "+ unionIndex784)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex785 = (decoder.readIndex()); + if (unionIndex785 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(785, null); + } else { + if (unionIndex785 == 1) { + Utf8 charSequence785; + Object oldString785 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(785); + if (oldString785 instanceof Utf8) { + charSequence785 = (decoder).readString(((Utf8) oldString785)); + } else { + charSequence785 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(785, charSequence785); + } else { + throw new RuntimeException(("Illegal union index for 'F785': "+ unionIndex785)); + } + } + int unionIndex786 = (decoder.readIndex()); + if (unionIndex786 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(786, null); + } else { + if (unionIndex786 == 1) { + Utf8 charSequence786; + Object oldString786 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(786); + if (oldString786 instanceof Utf8) { + charSequence786 = (decoder).readString(((Utf8) oldString786)); + } else { + charSequence786 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(786, charSequence786); + } else { + throw new RuntimeException(("Illegal union index for 'F786': "+ unionIndex786)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex787 = (decoder.readIndex()); + if (unionIndex787 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(787, null); + } else { + if (unionIndex787 == 1) { + Utf8 charSequence787; + Object oldString787 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(787); + if (oldString787 instanceof Utf8) { + charSequence787 = (decoder).readString(((Utf8) oldString787)); + } else { + charSequence787 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(787, charSequence787); + } else { + throw new RuntimeException(("Illegal union index for 'F787': "+ unionIndex787)); + } + } + int unionIndex788 = (decoder.readIndex()); + if (unionIndex788 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(788, null); + } else { + if (unionIndex788 == 1) { + Utf8 charSequence788; + Object oldString788 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(788); + if (oldString788 instanceof Utf8) { + charSequence788 = (decoder).readString(((Utf8) oldString788)); + } else { + charSequence788 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(788, charSequence788); + } else { + throw new RuntimeException(("Illegal union index for 'F788': "+ unionIndex788)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex789 = (decoder.readIndex()); + if (unionIndex789 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(789, null); + } else { + if (unionIndex789 == 1) { + Utf8 charSequence789; + Object oldString789 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(789); + if (oldString789 instanceof Utf8) { + charSequence789 = (decoder).readString(((Utf8) oldString789)); + } else { + charSequence789 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(789, charSequence789); + } else { + throw new RuntimeException(("Illegal union index for 'F789': "+ unionIndex789)); + } + } + int unionIndex790 = (decoder.readIndex()); + if (unionIndex790 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(790, null); + } else { + if (unionIndex790 == 1) { + Utf8 charSequence790; + Object oldString790 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(790); + if (oldString790 instanceof Utf8) { + charSequence790 = (decoder).readString(((Utf8) oldString790)); + } else { + charSequence790 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(790, charSequence790); + } else { + throw new RuntimeException(("Illegal union index for 'F790': "+ unionIndex790)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex791 = (decoder.readIndex()); + if (unionIndex791 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(791, null); + } else { + if (unionIndex791 == 1) { + Utf8 charSequence791; + Object oldString791 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(791); + if (oldString791 instanceof Utf8) { + charSequence791 = (decoder).readString(((Utf8) oldString791)); + } else { + charSequence791 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(791, charSequence791); + } else { + throw new RuntimeException(("Illegal union index for 'F791': "+ unionIndex791)); + } + } + int unionIndex792 = (decoder.readIndex()); + if (unionIndex792 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(792, null); + } else { + if (unionIndex792 == 1) { + Utf8 charSequence792; + Object oldString792 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(792); + if (oldString792 instanceof Utf8) { + charSequence792 = (decoder).readString(((Utf8) oldString792)); + } else { + charSequence792 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(792, charSequence792); + } else { + throw new RuntimeException(("Illegal union index for 'F792': "+ unionIndex792)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex793 = (decoder.readIndex()); + if (unionIndex793 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(793, null); + } else { + if (unionIndex793 == 1) { + Utf8 charSequence793; + Object oldString793 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(793); + if (oldString793 instanceof Utf8) { + charSequence793 = (decoder).readString(((Utf8) oldString793)); + } else { + charSequence793 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(793, charSequence793); + } else { + throw new RuntimeException(("Illegal union index for 'F793': "+ unionIndex793)); + } + } + int unionIndex794 = (decoder.readIndex()); + if (unionIndex794 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(794, null); + } else { + if (unionIndex794 == 1) { + Utf8 charSequence794; + Object oldString794 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(794); + if (oldString794 instanceof Utf8) { + charSequence794 = (decoder).readString(((Utf8) oldString794)); + } else { + charSequence794 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(794, charSequence794); + } else { + throw new RuntimeException(("Illegal union index for 'F794': "+ unionIndex794)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex795 = (decoder.readIndex()); + if (unionIndex795 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(795, null); + } else { + if (unionIndex795 == 1) { + Utf8 charSequence795; + Object oldString795 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(795); + if (oldString795 instanceof Utf8) { + charSequence795 = (decoder).readString(((Utf8) oldString795)); + } else { + charSequence795 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(795, charSequence795); + } else { + throw new RuntimeException(("Illegal union index for 'F795': "+ unionIndex795)); + } + } + int unionIndex796 = (decoder.readIndex()); + if (unionIndex796 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(796, null); + } else { + if (unionIndex796 == 1) { + Utf8 charSequence796; + Object oldString796 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(796); + if (oldString796 instanceof Utf8) { + charSequence796 = (decoder).readString(((Utf8) oldString796)); + } else { + charSequence796 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(796, charSequence796); + } else { + throw new RuntimeException(("Illegal union index for 'F796': "+ unionIndex796)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex797 = (decoder.readIndex()); + if (unionIndex797 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(797, null); + } else { + if (unionIndex797 == 1) { + Utf8 charSequence797; + Object oldString797 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(797); + if (oldString797 instanceof Utf8) { + charSequence797 = (decoder).readString(((Utf8) oldString797)); + } else { + charSequence797 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(797, charSequence797); + } else { + throw new RuntimeException(("Illegal union index for 'F797': "+ unionIndex797)); + } + } + int unionIndex798 = (decoder.readIndex()); + if (unionIndex798 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(798, null); + } else { + if (unionIndex798 == 1) { + Utf8 charSequence798; + Object oldString798 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(798); + if (oldString798 instanceof Utf8) { + charSequence798 = (decoder).readString(((Utf8) oldString798)); + } else { + charSequence798 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(798, charSequence798); + } else { + throw new RuntimeException(("Illegal union index for 'F798': "+ unionIndex798)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex799 = (decoder.readIndex()); + if (unionIndex799 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(799, null); + } else { + if (unionIndex799 == 1) { + Utf8 charSequence799; + Object oldString799 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(799); + if (oldString799 instanceof Utf8) { + charSequence799 = (decoder).readString(((Utf8) oldString799)); + } else { + charSequence799 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(799, charSequence799); + } else { + throw new RuntimeException(("Illegal union index for 'F799': "+ unionIndex799)); + } + } + int unionIndex800 = (decoder.readIndex()); + if (unionIndex800 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(800, null); + } else { + if (unionIndex800 == 1) { + Utf8 charSequence800; + Object oldString800 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(800); + if (oldString800 instanceof Utf8) { + charSequence800 = (decoder).readString(((Utf8) oldString800)); + } else { + charSequence800 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(800, charSequence800); + } else { + throw new RuntimeException(("Illegal union index for 'F800': "+ unionIndex800)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex801 = (decoder.readIndex()); + if (unionIndex801 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(801, null); + } else { + if (unionIndex801 == 1) { + Utf8 charSequence801; + Object oldString801 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(801); + if (oldString801 instanceof Utf8) { + charSequence801 = (decoder).readString(((Utf8) oldString801)); + } else { + charSequence801 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(801, charSequence801); + } else { + throw new RuntimeException(("Illegal union index for 'F801': "+ unionIndex801)); + } + } + int unionIndex802 = (decoder.readIndex()); + if (unionIndex802 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(802, null); + } else { + if (unionIndex802 == 1) { + Utf8 charSequence802; + Object oldString802 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(802); + if (oldString802 instanceof Utf8) { + charSequence802 = (decoder).readString(((Utf8) oldString802)); + } else { + charSequence802 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(802, charSequence802); + } else { + throw new RuntimeException(("Illegal union index for 'F802': "+ unionIndex802)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex803 = (decoder.readIndex()); + if (unionIndex803 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(803, null); + } else { + if (unionIndex803 == 1) { + Utf8 charSequence803; + Object oldString803 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(803); + if (oldString803 instanceof Utf8) { + charSequence803 = (decoder).readString(((Utf8) oldString803)); + } else { + charSequence803 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(803, charSequence803); + } else { + throw new RuntimeException(("Illegal union index for 'F803': "+ unionIndex803)); + } + } + int unionIndex804 = (decoder.readIndex()); + if (unionIndex804 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(804, null); + } else { + if (unionIndex804 == 1) { + Utf8 charSequence804; + Object oldString804 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(804); + if (oldString804 instanceof Utf8) { + charSequence804 = (decoder).readString(((Utf8) oldString804)); + } else { + charSequence804 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(804, charSequence804); + } else { + throw new RuntimeException(("Illegal union index for 'F804': "+ unionIndex804)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex805 = (decoder.readIndex()); + if (unionIndex805 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(805, null); + } else { + if (unionIndex805 == 1) { + Utf8 charSequence805; + Object oldString805 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(805); + if (oldString805 instanceof Utf8) { + charSequence805 = (decoder).readString(((Utf8) oldString805)); + } else { + charSequence805 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(805, charSequence805); + } else { + throw new RuntimeException(("Illegal union index for 'F805': "+ unionIndex805)); + } + } + int unionIndex806 = (decoder.readIndex()); + if (unionIndex806 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(806, null); + } else { + if (unionIndex806 == 1) { + Utf8 charSequence806; + Object oldString806 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(806); + if (oldString806 instanceof Utf8) { + charSequence806 = (decoder).readString(((Utf8) oldString806)); + } else { + charSequence806 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(806, charSequence806); + } else { + throw new RuntimeException(("Illegal union index for 'F806': "+ unionIndex806)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex807 = (decoder.readIndex()); + if (unionIndex807 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(807, null); + } else { + if (unionIndex807 == 1) { + Utf8 charSequence807; + Object oldString807 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(807); + if (oldString807 instanceof Utf8) { + charSequence807 = (decoder).readString(((Utf8) oldString807)); + } else { + charSequence807 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(807, charSequence807); + } else { + throw new RuntimeException(("Illegal union index for 'F807': "+ unionIndex807)); + } + } + int unionIndex808 = (decoder.readIndex()); + if (unionIndex808 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(808, null); + } else { + if (unionIndex808 == 1) { + Utf8 charSequence808; + Object oldString808 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(808); + if (oldString808 instanceof Utf8) { + charSequence808 = (decoder).readString(((Utf8) oldString808)); + } else { + charSequence808 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(808, charSequence808); + } else { + throw new RuntimeException(("Illegal union index for 'F808': "+ unionIndex808)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex809 = (decoder.readIndex()); + if (unionIndex809 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(809, null); + } else { + if (unionIndex809 == 1) { + Utf8 charSequence809; + Object oldString809 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(809); + if (oldString809 instanceof Utf8) { + charSequence809 = (decoder).readString(((Utf8) oldString809)); + } else { + charSequence809 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(809, charSequence809); + } else { + throw new RuntimeException(("Illegal union index for 'F809': "+ unionIndex809)); + } + } + int unionIndex810 = (decoder.readIndex()); + if (unionIndex810 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(810, null); + } else { + if (unionIndex810 == 1) { + Utf8 charSequence810; + Object oldString810 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(810); + if (oldString810 instanceof Utf8) { + charSequence810 = (decoder).readString(((Utf8) oldString810)); + } else { + charSequence810 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(810, charSequence810); + } else { + throw new RuntimeException(("Illegal union index for 'F810': "+ unionIndex810)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex811 = (decoder.readIndex()); + if (unionIndex811 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(811, null); + } else { + if (unionIndex811 == 1) { + Utf8 charSequence811; + Object oldString811 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(811); + if (oldString811 instanceof Utf8) { + charSequence811 = (decoder).readString(((Utf8) oldString811)); + } else { + charSequence811 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(811, charSequence811); + } else { + throw new RuntimeException(("Illegal union index for 'F811': "+ unionIndex811)); + } + } + int unionIndex812 = (decoder.readIndex()); + if (unionIndex812 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(812, null); + } else { + if (unionIndex812 == 1) { + Utf8 charSequence812; + Object oldString812 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(812); + if (oldString812 instanceof Utf8) { + charSequence812 = (decoder).readString(((Utf8) oldString812)); + } else { + charSequence812 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(812, charSequence812); + } else { + throw new RuntimeException(("Illegal union index for 'F812': "+ unionIndex812)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex813 = (decoder.readIndex()); + if (unionIndex813 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(813, null); + } else { + if (unionIndex813 == 1) { + Utf8 charSequence813; + Object oldString813 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(813); + if (oldString813 instanceof Utf8) { + charSequence813 = (decoder).readString(((Utf8) oldString813)); + } else { + charSequence813 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(813, charSequence813); + } else { + throw new RuntimeException(("Illegal union index for 'F813': "+ unionIndex813)); + } + } + int unionIndex814 = (decoder.readIndex()); + if (unionIndex814 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(814, null); + } else { + if (unionIndex814 == 1) { + Utf8 charSequence814; + Object oldString814 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(814); + if (oldString814 instanceof Utf8) { + charSequence814 = (decoder).readString(((Utf8) oldString814)); + } else { + charSequence814 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(814, charSequence814); + } else { + throw new RuntimeException(("Illegal union index for 'F814': "+ unionIndex814)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex815 = (decoder.readIndex()); + if (unionIndex815 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(815, null); + } else { + if (unionIndex815 == 1) { + Utf8 charSequence815; + Object oldString815 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(815); + if (oldString815 instanceof Utf8) { + charSequence815 = (decoder).readString(((Utf8) oldString815)); + } else { + charSequence815 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(815, charSequence815); + } else { + throw new RuntimeException(("Illegal union index for 'F815': "+ unionIndex815)); + } + } + int unionIndex816 = (decoder.readIndex()); + if (unionIndex816 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(816, null); + } else { + if (unionIndex816 == 1) { + Utf8 charSequence816; + Object oldString816 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(816); + if (oldString816 instanceof Utf8) { + charSequence816 = (decoder).readString(((Utf8) oldString816)); + } else { + charSequence816 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(816, charSequence816); + } else { + throw new RuntimeException(("Illegal union index for 'F816': "+ unionIndex816)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex817 = (decoder.readIndex()); + if (unionIndex817 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(817, null); + } else { + if (unionIndex817 == 1) { + Utf8 charSequence817; + Object oldString817 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(817); + if (oldString817 instanceof Utf8) { + charSequence817 = (decoder).readString(((Utf8) oldString817)); + } else { + charSequence817 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(817, charSequence817); + } else { + throw new RuntimeException(("Illegal union index for 'F817': "+ unionIndex817)); + } + } + int unionIndex818 = (decoder.readIndex()); + if (unionIndex818 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(818, null); + } else { + if (unionIndex818 == 1) { + Utf8 charSequence818; + Object oldString818 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(818); + if (oldString818 instanceof Utf8) { + charSequence818 = (decoder).readString(((Utf8) oldString818)); + } else { + charSequence818 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(818, charSequence818); + } else { + throw new RuntimeException(("Illegal union index for 'F818': "+ unionIndex818)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex819 = (decoder.readIndex()); + if (unionIndex819 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(819, null); + } else { + if (unionIndex819 == 1) { + Utf8 charSequence819; + Object oldString819 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(819); + if (oldString819 instanceof Utf8) { + charSequence819 = (decoder).readString(((Utf8) oldString819)); + } else { + charSequence819 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(819, charSequence819); + } else { + throw new RuntimeException(("Illegal union index for 'F819': "+ unionIndex819)); + } + } + int unionIndex820 = (decoder.readIndex()); + if (unionIndex820 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(820, null); + } else { + if (unionIndex820 == 1) { + Utf8 charSequence820; + Object oldString820 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(820); + if (oldString820 instanceof Utf8) { + charSequence820 = (decoder).readString(((Utf8) oldString820)); + } else { + charSequence820 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(820, charSequence820); + } else { + throw new RuntimeException(("Illegal union index for 'F820': "+ unionIndex820)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex821 = (decoder.readIndex()); + if (unionIndex821 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(821, null); + } else { + if (unionIndex821 == 1) { + Utf8 charSequence821; + Object oldString821 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(821); + if (oldString821 instanceof Utf8) { + charSequence821 = (decoder).readString(((Utf8) oldString821)); + } else { + charSequence821 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(821, charSequence821); + } else { + throw new RuntimeException(("Illegal union index for 'F821': "+ unionIndex821)); + } + } + int unionIndex822 = (decoder.readIndex()); + if (unionIndex822 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(822, null); + } else { + if (unionIndex822 == 1) { + Utf8 charSequence822; + Object oldString822 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(822); + if (oldString822 instanceof Utf8) { + charSequence822 = (decoder).readString(((Utf8) oldString822)); + } else { + charSequence822 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(822, charSequence822); + } else { + throw new RuntimeException(("Illegal union index for 'F822': "+ unionIndex822)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex823 = (decoder.readIndex()); + if (unionIndex823 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(823, null); + } else { + if (unionIndex823 == 1) { + Utf8 charSequence823; + Object oldString823 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(823); + if (oldString823 instanceof Utf8) { + charSequence823 = (decoder).readString(((Utf8) oldString823)); + } else { + charSequence823 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(823, charSequence823); + } else { + throw new RuntimeException(("Illegal union index for 'F823': "+ unionIndex823)); + } + } + int unionIndex824 = (decoder.readIndex()); + if (unionIndex824 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(824, null); + } else { + if (unionIndex824 == 1) { + Utf8 charSequence824; + Object oldString824 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(824); + if (oldString824 instanceof Utf8) { + charSequence824 = (decoder).readString(((Utf8) oldString824)); + } else { + charSequence824 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(824, charSequence824); + } else { + throw new RuntimeException(("Illegal union index for 'F824': "+ unionIndex824)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex825 = (decoder.readIndex()); + if (unionIndex825 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(825, null); + } else { + if (unionIndex825 == 1) { + Utf8 charSequence825; + Object oldString825 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(825); + if (oldString825 instanceof Utf8) { + charSequence825 = (decoder).readString(((Utf8) oldString825)); + } else { + charSequence825 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(825, charSequence825); + } else { + throw new RuntimeException(("Illegal union index for 'F825': "+ unionIndex825)); + } + } + int unionIndex826 = (decoder.readIndex()); + if (unionIndex826 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(826, null); + } else { + if (unionIndex826 == 1) { + Utf8 charSequence826; + Object oldString826 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(826); + if (oldString826 instanceof Utf8) { + charSequence826 = (decoder).readString(((Utf8) oldString826)); + } else { + charSequence826 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(826, charSequence826); + } else { + throw new RuntimeException(("Illegal union index for 'F826': "+ unionIndex826)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex827 = (decoder.readIndex()); + if (unionIndex827 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(827, null); + } else { + if (unionIndex827 == 1) { + Utf8 charSequence827; + Object oldString827 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(827); + if (oldString827 instanceof Utf8) { + charSequence827 = (decoder).readString(((Utf8) oldString827)); + } else { + charSequence827 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(827, charSequence827); + } else { + throw new RuntimeException(("Illegal union index for 'F827': "+ unionIndex827)); + } + } + int unionIndex828 = (decoder.readIndex()); + if (unionIndex828 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(828, null); + } else { + if (unionIndex828 == 1) { + Utf8 charSequence828; + Object oldString828 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(828); + if (oldString828 instanceof Utf8) { + charSequence828 = (decoder).readString(((Utf8) oldString828)); + } else { + charSequence828 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(828, charSequence828); + } else { + throw new RuntimeException(("Illegal union index for 'F828': "+ unionIndex828)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex829 = (decoder.readIndex()); + if (unionIndex829 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(829, null); + } else { + if (unionIndex829 == 1) { + Utf8 charSequence829; + Object oldString829 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(829); + if (oldString829 instanceof Utf8) { + charSequence829 = (decoder).readString(((Utf8) oldString829)); + } else { + charSequence829 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(829, charSequence829); + } else { + throw new RuntimeException(("Illegal union index for 'F829': "+ unionIndex829)); + } + } + int unionIndex830 = (decoder.readIndex()); + if (unionIndex830 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(830, null); + } else { + if (unionIndex830 == 1) { + Utf8 charSequence830; + Object oldString830 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(830); + if (oldString830 instanceof Utf8) { + charSequence830 = (decoder).readString(((Utf8) oldString830)); + } else { + charSequence830 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(830, charSequence830); + } else { + throw new RuntimeException(("Illegal union index for 'F830': "+ unionIndex830)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex831 = (decoder.readIndex()); + if (unionIndex831 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(831, null); + } else { + if (unionIndex831 == 1) { + Utf8 charSequence831; + Object oldString831 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(831); + if (oldString831 instanceof Utf8) { + charSequence831 = (decoder).readString(((Utf8) oldString831)); + } else { + charSequence831 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(831, charSequence831); + } else { + throw new RuntimeException(("Illegal union index for 'F831': "+ unionIndex831)); + } + } + int unionIndex832 = (decoder.readIndex()); + if (unionIndex832 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(832, null); + } else { + if (unionIndex832 == 1) { + Utf8 charSequence832; + Object oldString832 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(832); + if (oldString832 instanceof Utf8) { + charSequence832 = (decoder).readString(((Utf8) oldString832)); + } else { + charSequence832 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(832, charSequence832); + } else { + throw new RuntimeException(("Illegal union index for 'F832': "+ unionIndex832)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex833 = (decoder.readIndex()); + if (unionIndex833 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(833, null); + } else { + if (unionIndex833 == 1) { + Utf8 charSequence833; + Object oldString833 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(833); + if (oldString833 instanceof Utf8) { + charSequence833 = (decoder).readString(((Utf8) oldString833)); + } else { + charSequence833 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(833, charSequence833); + } else { + throw new RuntimeException(("Illegal union index for 'F833': "+ unionIndex833)); + } + } + int unionIndex834 = (decoder.readIndex()); + if (unionIndex834 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(834, null); + } else { + if (unionIndex834 == 1) { + Utf8 charSequence834; + Object oldString834 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(834); + if (oldString834 instanceof Utf8) { + charSequence834 = (decoder).readString(((Utf8) oldString834)); + } else { + charSequence834 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(834, charSequence834); + } else { + throw new RuntimeException(("Illegal union index for 'F834': "+ unionIndex834)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex835 = (decoder.readIndex()); + if (unionIndex835 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(835, null); + } else { + if (unionIndex835 == 1) { + Utf8 charSequence835; + Object oldString835 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(835); + if (oldString835 instanceof Utf8) { + charSequence835 = (decoder).readString(((Utf8) oldString835)); + } else { + charSequence835 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(835, charSequence835); + } else { + throw new RuntimeException(("Illegal union index for 'F835': "+ unionIndex835)); + } + } + int unionIndex836 = (decoder.readIndex()); + if (unionIndex836 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(836, null); + } else { + if (unionIndex836 == 1) { + Utf8 charSequence836; + Object oldString836 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(836); + if (oldString836 instanceof Utf8) { + charSequence836 = (decoder).readString(((Utf8) oldString836)); + } else { + charSequence836 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(836, charSequence836); + } else { + throw new RuntimeException(("Illegal union index for 'F836': "+ unionIndex836)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex837 = (decoder.readIndex()); + if (unionIndex837 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(837, null); + } else { + if (unionIndex837 == 1) { + Utf8 charSequence837; + Object oldString837 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(837); + if (oldString837 instanceof Utf8) { + charSequence837 = (decoder).readString(((Utf8) oldString837)); + } else { + charSequence837 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(837, charSequence837); + } else { + throw new RuntimeException(("Illegal union index for 'F837': "+ unionIndex837)); + } + } + int unionIndex838 = (decoder.readIndex()); + if (unionIndex838 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(838, null); + } else { + if (unionIndex838 == 1) { + Utf8 charSequence838; + Object oldString838 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(838); + if (oldString838 instanceof Utf8) { + charSequence838 = (decoder).readString(((Utf8) oldString838)); + } else { + charSequence838 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(838, charSequence838); + } else { + throw new RuntimeException(("Illegal union index for 'F838': "+ unionIndex838)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex839 = (decoder.readIndex()); + if (unionIndex839 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(839, null); + } else { + if (unionIndex839 == 1) { + Utf8 charSequence839; + Object oldString839 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(839); + if (oldString839 instanceof Utf8) { + charSequence839 = (decoder).readString(((Utf8) oldString839)); + } else { + charSequence839 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(839, charSequence839); + } else { + throw new RuntimeException(("Illegal union index for 'F839': "+ unionIndex839)); + } + } + int unionIndex840 = (decoder.readIndex()); + if (unionIndex840 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(840, null); + } else { + if (unionIndex840 == 1) { + Utf8 charSequence840; + Object oldString840 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(840); + if (oldString840 instanceof Utf8) { + charSequence840 = (decoder).readString(((Utf8) oldString840)); + } else { + charSequence840 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(840, charSequence840); + } else { + throw new RuntimeException(("Illegal union index for 'F840': "+ unionIndex840)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex841 = (decoder.readIndex()); + if (unionIndex841 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(841, null); + } else { + if (unionIndex841 == 1) { + Utf8 charSequence841; + Object oldString841 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(841); + if (oldString841 instanceof Utf8) { + charSequence841 = (decoder).readString(((Utf8) oldString841)); + } else { + charSequence841 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(841, charSequence841); + } else { + throw new RuntimeException(("Illegal union index for 'F841': "+ unionIndex841)); + } + } + int unionIndex842 = (decoder.readIndex()); + if (unionIndex842 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(842, null); + } else { + if (unionIndex842 == 1) { + Utf8 charSequence842; + Object oldString842 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(842); + if (oldString842 instanceof Utf8) { + charSequence842 = (decoder).readString(((Utf8) oldString842)); + } else { + charSequence842 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(842, charSequence842); + } else { + throw new RuntimeException(("Illegal union index for 'F842': "+ unionIndex842)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex843 = (decoder.readIndex()); + if (unionIndex843 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(843, null); + } else { + if (unionIndex843 == 1) { + Utf8 charSequence843; + Object oldString843 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(843); + if (oldString843 instanceof Utf8) { + charSequence843 = (decoder).readString(((Utf8) oldString843)); + } else { + charSequence843 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(843, charSequence843); + } else { + throw new RuntimeException(("Illegal union index for 'F843': "+ unionIndex843)); + } + } + int unionIndex844 = (decoder.readIndex()); + if (unionIndex844 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(844, null); + } else { + if (unionIndex844 == 1) { + Utf8 charSequence844; + Object oldString844 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(844); + if (oldString844 instanceof Utf8) { + charSequence844 = (decoder).readString(((Utf8) oldString844)); + } else { + charSequence844 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(844, charSequence844); + } else { + throw new RuntimeException(("Illegal union index for 'F844': "+ unionIndex844)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex845 = (decoder.readIndex()); + if (unionIndex845 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(845, null); + } else { + if (unionIndex845 == 1) { + Utf8 charSequence845; + Object oldString845 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(845); + if (oldString845 instanceof Utf8) { + charSequence845 = (decoder).readString(((Utf8) oldString845)); + } else { + charSequence845 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(845, charSequence845); + } else { + throw new RuntimeException(("Illegal union index for 'F845': "+ unionIndex845)); + } + } + int unionIndex846 = (decoder.readIndex()); + if (unionIndex846 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(846, null); + } else { + if (unionIndex846 == 1) { + Utf8 charSequence846; + Object oldString846 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(846); + if (oldString846 instanceof Utf8) { + charSequence846 = (decoder).readString(((Utf8) oldString846)); + } else { + charSequence846 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(846, charSequence846); + } else { + throw new RuntimeException(("Illegal union index for 'F846': "+ unionIndex846)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex847 = (decoder.readIndex()); + if (unionIndex847 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(847, null); + } else { + if (unionIndex847 == 1) { + Utf8 charSequence847; + Object oldString847 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(847); + if (oldString847 instanceof Utf8) { + charSequence847 = (decoder).readString(((Utf8) oldString847)); + } else { + charSequence847 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(847, charSequence847); + } else { + throw new RuntimeException(("Illegal union index for 'F847': "+ unionIndex847)); + } + } + int unionIndex848 = (decoder.readIndex()); + if (unionIndex848 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(848, null); + } else { + if (unionIndex848 == 1) { + Utf8 charSequence848; + Object oldString848 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(848); + if (oldString848 instanceof Utf8) { + charSequence848 = (decoder).readString(((Utf8) oldString848)); + } else { + charSequence848 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(848, charSequence848); + } else { + throw new RuntimeException(("Illegal union index for 'F848': "+ unionIndex848)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex849 = (decoder.readIndex()); + if (unionIndex849 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(849, null); + } else { + if (unionIndex849 == 1) { + Utf8 charSequence849; + Object oldString849 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(849); + if (oldString849 instanceof Utf8) { + charSequence849 = (decoder).readString(((Utf8) oldString849)); + } else { + charSequence849 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(849, charSequence849); + } else { + throw new RuntimeException(("Illegal union index for 'F849': "+ unionIndex849)); + } + } + int unionIndex850 = (decoder.readIndex()); + if (unionIndex850 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(850, null); + } else { + if (unionIndex850 == 1) { + Utf8 charSequence850; + Object oldString850 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(850); + if (oldString850 instanceof Utf8) { + charSequence850 = (decoder).readString(((Utf8) oldString850)); + } else { + charSequence850 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(850, charSequence850); + } else { + throw new RuntimeException(("Illegal union index for 'F850': "+ unionIndex850)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex851 = (decoder.readIndex()); + if (unionIndex851 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(851, null); + } else { + if (unionIndex851 == 1) { + Utf8 charSequence851; + Object oldString851 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(851); + if (oldString851 instanceof Utf8) { + charSequence851 = (decoder).readString(((Utf8) oldString851)); + } else { + charSequence851 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(851, charSequence851); + } else { + throw new RuntimeException(("Illegal union index for 'F851': "+ unionIndex851)); + } + } + int unionIndex852 = (decoder.readIndex()); + if (unionIndex852 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(852, null); + } else { + if (unionIndex852 == 1) { + Utf8 charSequence852; + Object oldString852 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(852); + if (oldString852 instanceof Utf8) { + charSequence852 = (decoder).readString(((Utf8) oldString852)); + } else { + charSequence852 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(852, charSequence852); + } else { + throw new RuntimeException(("Illegal union index for 'F852': "+ unionIndex852)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex853 = (decoder.readIndex()); + if (unionIndex853 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(853, null); + } else { + if (unionIndex853 == 1) { + Utf8 charSequence853; + Object oldString853 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(853); + if (oldString853 instanceof Utf8) { + charSequence853 = (decoder).readString(((Utf8) oldString853)); + } else { + charSequence853 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(853, charSequence853); + } else { + throw new RuntimeException(("Illegal union index for 'F853': "+ unionIndex853)); + } + } + int unionIndex854 = (decoder.readIndex()); + if (unionIndex854 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(854, null); + } else { + if (unionIndex854 == 1) { + Utf8 charSequence854; + Object oldString854 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(854); + if (oldString854 instanceof Utf8) { + charSequence854 = (decoder).readString(((Utf8) oldString854)); + } else { + charSequence854 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(854, charSequence854); + } else { + throw new RuntimeException(("Illegal union index for 'F854': "+ unionIndex854)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex855 = (decoder.readIndex()); + if (unionIndex855 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(855, null); + } else { + if (unionIndex855 == 1) { + Utf8 charSequence855; + Object oldString855 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(855); + if (oldString855 instanceof Utf8) { + charSequence855 = (decoder).readString(((Utf8) oldString855)); + } else { + charSequence855 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(855, charSequence855); + } else { + throw new RuntimeException(("Illegal union index for 'F855': "+ unionIndex855)); + } + } + int unionIndex856 = (decoder.readIndex()); + if (unionIndex856 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(856, null); + } else { + if (unionIndex856 == 1) { + Utf8 charSequence856; + Object oldString856 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(856); + if (oldString856 instanceof Utf8) { + charSequence856 = (decoder).readString(((Utf8) oldString856)); + } else { + charSequence856 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(856, charSequence856); + } else { + throw new RuntimeException(("Illegal union index for 'F856': "+ unionIndex856)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex857 = (decoder.readIndex()); + if (unionIndex857 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(857, null); + } else { + if (unionIndex857 == 1) { + Utf8 charSequence857; + Object oldString857 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(857); + if (oldString857 instanceof Utf8) { + charSequence857 = (decoder).readString(((Utf8) oldString857)); + } else { + charSequence857 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(857, charSequence857); + } else { + throw new RuntimeException(("Illegal union index for 'F857': "+ unionIndex857)); + } + } + int unionIndex858 = (decoder.readIndex()); + if (unionIndex858 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(858, null); + } else { + if (unionIndex858 == 1) { + Utf8 charSequence858; + Object oldString858 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(858); + if (oldString858 instanceof Utf8) { + charSequence858 = (decoder).readString(((Utf8) oldString858)); + } else { + charSequence858 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(858, charSequence858); + } else { + throw new RuntimeException(("Illegal union index for 'F858': "+ unionIndex858)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex859 = (decoder.readIndex()); + if (unionIndex859 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(859, null); + } else { + if (unionIndex859 == 1) { + Utf8 charSequence859; + Object oldString859 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(859); + if (oldString859 instanceof Utf8) { + charSequence859 = (decoder).readString(((Utf8) oldString859)); + } else { + charSequence859 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(859, charSequence859); + } else { + throw new RuntimeException(("Illegal union index for 'F859': "+ unionIndex859)); + } + } + int unionIndex860 = (decoder.readIndex()); + if (unionIndex860 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(860, null); + } else { + if (unionIndex860 == 1) { + Utf8 charSequence860; + Object oldString860 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(860); + if (oldString860 instanceof Utf8) { + charSequence860 = (decoder).readString(((Utf8) oldString860)); + } else { + charSequence860 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(860, charSequence860); + } else { + throw new RuntimeException(("Illegal union index for 'F860': "+ unionIndex860)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex861 = (decoder.readIndex()); + if (unionIndex861 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(861, null); + } else { + if (unionIndex861 == 1) { + Utf8 charSequence861; + Object oldString861 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(861); + if (oldString861 instanceof Utf8) { + charSequence861 = (decoder).readString(((Utf8) oldString861)); + } else { + charSequence861 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(861, charSequence861); + } else { + throw new RuntimeException(("Illegal union index for 'F861': "+ unionIndex861)); + } + } + int unionIndex862 = (decoder.readIndex()); + if (unionIndex862 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(862, null); + } else { + if (unionIndex862 == 1) { + Utf8 charSequence862; + Object oldString862 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(862); + if (oldString862 instanceof Utf8) { + charSequence862 = (decoder).readString(((Utf8) oldString862)); + } else { + charSequence862 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(862, charSequence862); + } else { + throw new RuntimeException(("Illegal union index for 'F862': "+ unionIndex862)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex863 = (decoder.readIndex()); + if (unionIndex863 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(863, null); + } else { + if (unionIndex863 == 1) { + Utf8 charSequence863; + Object oldString863 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(863); + if (oldString863 instanceof Utf8) { + charSequence863 = (decoder).readString(((Utf8) oldString863)); + } else { + charSequence863 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(863, charSequence863); + } else { + throw new RuntimeException(("Illegal union index for 'F863': "+ unionIndex863)); + } + } + int unionIndex864 = (decoder.readIndex()); + if (unionIndex864 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(864, null); + } else { + if (unionIndex864 == 1) { + Utf8 charSequence864; + Object oldString864 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(864); + if (oldString864 instanceof Utf8) { + charSequence864 = (decoder).readString(((Utf8) oldString864)); + } else { + charSequence864 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(864, charSequence864); + } else { + throw new RuntimeException(("Illegal union index for 'F864': "+ unionIndex864)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex865 = (decoder.readIndex()); + if (unionIndex865 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(865, null); + } else { + if (unionIndex865 == 1) { + Utf8 charSequence865; + Object oldString865 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(865); + if (oldString865 instanceof Utf8) { + charSequence865 = (decoder).readString(((Utf8) oldString865)); + } else { + charSequence865 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(865, charSequence865); + } else { + throw new RuntimeException(("Illegal union index for 'F865': "+ unionIndex865)); + } + } + int unionIndex866 = (decoder.readIndex()); + if (unionIndex866 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(866, null); + } else { + if (unionIndex866 == 1) { + Utf8 charSequence866; + Object oldString866 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(866); + if (oldString866 instanceof Utf8) { + charSequence866 = (decoder).readString(((Utf8) oldString866)); + } else { + charSequence866 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(866, charSequence866); + } else { + throw new RuntimeException(("Illegal union index for 'F866': "+ unionIndex866)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex867 = (decoder.readIndex()); + if (unionIndex867 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(867, null); + } else { + if (unionIndex867 == 1) { + Utf8 charSequence867; + Object oldString867 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(867); + if (oldString867 instanceof Utf8) { + charSequence867 = (decoder).readString(((Utf8) oldString867)); + } else { + charSequence867 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(867, charSequence867); + } else { + throw new RuntimeException(("Illegal union index for 'F867': "+ unionIndex867)); + } + } + int unionIndex868 = (decoder.readIndex()); + if (unionIndex868 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(868, null); + } else { + if (unionIndex868 == 1) { + Utf8 charSequence868; + Object oldString868 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(868); + if (oldString868 instanceof Utf8) { + charSequence868 = (decoder).readString(((Utf8) oldString868)); + } else { + charSequence868 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(868, charSequence868); + } else { + throw new RuntimeException(("Illegal union index for 'F868': "+ unionIndex868)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex869 = (decoder.readIndex()); + if (unionIndex869 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(869, null); + } else { + if (unionIndex869 == 1) { + Utf8 charSequence869; + Object oldString869 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(869); + if (oldString869 instanceof Utf8) { + charSequence869 = (decoder).readString(((Utf8) oldString869)); + } else { + charSequence869 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(869, charSequence869); + } else { + throw new RuntimeException(("Illegal union index for 'F869': "+ unionIndex869)); + } + } + int unionIndex870 = (decoder.readIndex()); + if (unionIndex870 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(870, null); + } else { + if (unionIndex870 == 1) { + Utf8 charSequence870; + Object oldString870 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(870); + if (oldString870 instanceof Utf8) { + charSequence870 = (decoder).readString(((Utf8) oldString870)); + } else { + charSequence870 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(870, charSequence870); + } else { + throw new RuntimeException(("Illegal union index for 'F870': "+ unionIndex870)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex871 = (decoder.readIndex()); + if (unionIndex871 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(871, null); + } else { + if (unionIndex871 == 1) { + Utf8 charSequence871; + Object oldString871 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(871); + if (oldString871 instanceof Utf8) { + charSequence871 = (decoder).readString(((Utf8) oldString871)); + } else { + charSequence871 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(871, charSequence871); + } else { + throw new RuntimeException(("Illegal union index for 'F871': "+ unionIndex871)); + } + } + int unionIndex872 = (decoder.readIndex()); + if (unionIndex872 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(872, null); + } else { + if (unionIndex872 == 1) { + Utf8 charSequence872; + Object oldString872 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(872); + if (oldString872 instanceof Utf8) { + charSequence872 = (decoder).readString(((Utf8) oldString872)); + } else { + charSequence872 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(872, charSequence872); + } else { + throw new RuntimeException(("Illegal union index for 'F872': "+ unionIndex872)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex873 = (decoder.readIndex()); + if (unionIndex873 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(873, null); + } else { + if (unionIndex873 == 1) { + Utf8 charSequence873; + Object oldString873 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(873); + if (oldString873 instanceof Utf8) { + charSequence873 = (decoder).readString(((Utf8) oldString873)); + } else { + charSequence873 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(873, charSequence873); + } else { + throw new RuntimeException(("Illegal union index for 'F873': "+ unionIndex873)); + } + } + int unionIndex874 = (decoder.readIndex()); + if (unionIndex874 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(874, null); + } else { + if (unionIndex874 == 1) { + Utf8 charSequence874; + Object oldString874 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(874); + if (oldString874 instanceof Utf8) { + charSequence874 = (decoder).readString(((Utf8) oldString874)); + } else { + charSequence874 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(874, charSequence874); + } else { + throw new RuntimeException(("Illegal union index for 'F874': "+ unionIndex874)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex875 = (decoder.readIndex()); + if (unionIndex875 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(875, null); + } else { + if (unionIndex875 == 1) { + Utf8 charSequence875; + Object oldString875 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(875); + if (oldString875 instanceof Utf8) { + charSequence875 = (decoder).readString(((Utf8) oldString875)); + } else { + charSequence875 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(875, charSequence875); + } else { + throw new RuntimeException(("Illegal union index for 'F875': "+ unionIndex875)); + } + } + int unionIndex876 = (decoder.readIndex()); + if (unionIndex876 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(876, null); + } else { + if (unionIndex876 == 1) { + Utf8 charSequence876; + Object oldString876 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(876); + if (oldString876 instanceof Utf8) { + charSequence876 = (decoder).readString(((Utf8) oldString876)); + } else { + charSequence876 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(876, charSequence876); + } else { + throw new RuntimeException(("Illegal union index for 'F876': "+ unionIndex876)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex877 = (decoder.readIndex()); + if (unionIndex877 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(877, null); + } else { + if (unionIndex877 == 1) { + Utf8 charSequence877; + Object oldString877 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(877); + if (oldString877 instanceof Utf8) { + charSequence877 = (decoder).readString(((Utf8) oldString877)); + } else { + charSequence877 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(877, charSequence877); + } else { + throw new RuntimeException(("Illegal union index for 'F877': "+ unionIndex877)); + } + } + int unionIndex878 = (decoder.readIndex()); + if (unionIndex878 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(878, null); + } else { + if (unionIndex878 == 1) { + Utf8 charSequence878; + Object oldString878 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(878); + if (oldString878 instanceof Utf8) { + charSequence878 = (decoder).readString(((Utf8) oldString878)); + } else { + charSequence878 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(878, charSequence878); + } else { + throw new RuntimeException(("Illegal union index for 'F878': "+ unionIndex878)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex879 = (decoder.readIndex()); + if (unionIndex879 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(879, null); + } else { + if (unionIndex879 == 1) { + Utf8 charSequence879; + Object oldString879 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(879); + if (oldString879 instanceof Utf8) { + charSequence879 = (decoder).readString(((Utf8) oldString879)); + } else { + charSequence879 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(879, charSequence879); + } else { + throw new RuntimeException(("Illegal union index for 'F879': "+ unionIndex879)); + } + } + int unionIndex880 = (decoder.readIndex()); + if (unionIndex880 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(880, null); + } else { + if (unionIndex880 == 1) { + Utf8 charSequence880; + Object oldString880 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(880); + if (oldString880 instanceof Utf8) { + charSequence880 = (decoder).readString(((Utf8) oldString880)); + } else { + charSequence880 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(880, charSequence880); + } else { + throw new RuntimeException(("Illegal union index for 'F880': "+ unionIndex880)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex881 = (decoder.readIndex()); + if (unionIndex881 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(881, null); + } else { + if (unionIndex881 == 1) { + Utf8 charSequence881; + Object oldString881 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(881); + if (oldString881 instanceof Utf8) { + charSequence881 = (decoder).readString(((Utf8) oldString881)); + } else { + charSequence881 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(881, charSequence881); + } else { + throw new RuntimeException(("Illegal union index for 'F881': "+ unionIndex881)); + } + } + int unionIndex882 = (decoder.readIndex()); + if (unionIndex882 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(882, null); + } else { + if (unionIndex882 == 1) { + Utf8 charSequence882; + Object oldString882 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(882); + if (oldString882 instanceof Utf8) { + charSequence882 = (decoder).readString(((Utf8) oldString882)); + } else { + charSequence882 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(882, charSequence882); + } else { + throw new RuntimeException(("Illegal union index for 'F882': "+ unionIndex882)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex883 = (decoder.readIndex()); + if (unionIndex883 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(883, null); + } else { + if (unionIndex883 == 1) { + Utf8 charSequence883; + Object oldString883 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(883); + if (oldString883 instanceof Utf8) { + charSequence883 = (decoder).readString(((Utf8) oldString883)); + } else { + charSequence883 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(883, charSequence883); + } else { + throw new RuntimeException(("Illegal union index for 'F883': "+ unionIndex883)); + } + } + int unionIndex884 = (decoder.readIndex()); + if (unionIndex884 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(884, null); + } else { + if (unionIndex884 == 1) { + Utf8 charSequence884; + Object oldString884 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(884); + if (oldString884 instanceof Utf8) { + charSequence884 = (decoder).readString(((Utf8) oldString884)); + } else { + charSequence884 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(884, charSequence884); + } else { + throw new RuntimeException(("Illegal union index for 'F884': "+ unionIndex884)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex885 = (decoder.readIndex()); + if (unionIndex885 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(885, null); + } else { + if (unionIndex885 == 1) { + Utf8 charSequence885; + Object oldString885 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(885); + if (oldString885 instanceof Utf8) { + charSequence885 = (decoder).readString(((Utf8) oldString885)); + } else { + charSequence885 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(885, charSequence885); + } else { + throw new RuntimeException(("Illegal union index for 'F885': "+ unionIndex885)); + } + } + int unionIndex886 = (decoder.readIndex()); + if (unionIndex886 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(886, null); + } else { + if (unionIndex886 == 1) { + Utf8 charSequence886; + Object oldString886 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(886); + if (oldString886 instanceof Utf8) { + charSequence886 = (decoder).readString(((Utf8) oldString886)); + } else { + charSequence886 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(886, charSequence886); + } else { + throw new RuntimeException(("Illegal union index for 'F886': "+ unionIndex886)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex887 = (decoder.readIndex()); + if (unionIndex887 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(887, null); + } else { + if (unionIndex887 == 1) { + Utf8 charSequence887; + Object oldString887 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(887); + if (oldString887 instanceof Utf8) { + charSequence887 = (decoder).readString(((Utf8) oldString887)); + } else { + charSequence887 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(887, charSequence887); + } else { + throw new RuntimeException(("Illegal union index for 'F887': "+ unionIndex887)); + } + } + int unionIndex888 = (decoder.readIndex()); + if (unionIndex888 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(888, null); + } else { + if (unionIndex888 == 1) { + Utf8 charSequence888; + Object oldString888 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(888); + if (oldString888 instanceof Utf8) { + charSequence888 = (decoder).readString(((Utf8) oldString888)); + } else { + charSequence888 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(888, charSequence888); + } else { + throw new RuntimeException(("Illegal union index for 'F888': "+ unionIndex888)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex889 = (decoder.readIndex()); + if (unionIndex889 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(889, null); + } else { + if (unionIndex889 == 1) { + Utf8 charSequence889; + Object oldString889 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(889); + if (oldString889 instanceof Utf8) { + charSequence889 = (decoder).readString(((Utf8) oldString889)); + } else { + charSequence889 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(889, charSequence889); + } else { + throw new RuntimeException(("Illegal union index for 'F889': "+ unionIndex889)); + } + } + int unionIndex890 = (decoder.readIndex()); + if (unionIndex890 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(890, null); + } else { + if (unionIndex890 == 1) { + Utf8 charSequence890; + Object oldString890 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(890); + if (oldString890 instanceof Utf8) { + charSequence890 = (decoder).readString(((Utf8) oldString890)); + } else { + charSequence890 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(890, charSequence890); + } else { + throw new RuntimeException(("Illegal union index for 'F890': "+ unionIndex890)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex891 = (decoder.readIndex()); + if (unionIndex891 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(891, null); + } else { + if (unionIndex891 == 1) { + Utf8 charSequence891; + Object oldString891 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(891); + if (oldString891 instanceof Utf8) { + charSequence891 = (decoder).readString(((Utf8) oldString891)); + } else { + charSequence891 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(891, charSequence891); + } else { + throw new RuntimeException(("Illegal union index for 'F891': "+ unionIndex891)); + } + } + int unionIndex892 = (decoder.readIndex()); + if (unionIndex892 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(892, null); + } else { + if (unionIndex892 == 1) { + Utf8 charSequence892; + Object oldString892 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(892); + if (oldString892 instanceof Utf8) { + charSequence892 = (decoder).readString(((Utf8) oldString892)); + } else { + charSequence892 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(892, charSequence892); + } else { + throw new RuntimeException(("Illegal union index for 'F892': "+ unionIndex892)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex893 = (decoder.readIndex()); + if (unionIndex893 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(893, null); + } else { + if (unionIndex893 == 1) { + Utf8 charSequence893; + Object oldString893 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(893); + if (oldString893 instanceof Utf8) { + charSequence893 = (decoder).readString(((Utf8) oldString893)); + } else { + charSequence893 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(893, charSequence893); + } else { + throw new RuntimeException(("Illegal union index for 'F893': "+ unionIndex893)); + } + } + int unionIndex894 = (decoder.readIndex()); + if (unionIndex894 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(894, null); + } else { + if (unionIndex894 == 1) { + Utf8 charSequence894; + Object oldString894 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(894); + if (oldString894 instanceof Utf8) { + charSequence894 = (decoder).readString(((Utf8) oldString894)); + } else { + charSequence894 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(894, charSequence894); + } else { + throw new RuntimeException(("Illegal union index for 'F894': "+ unionIndex894)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex895 = (decoder.readIndex()); + if (unionIndex895 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(895, null); + } else { + if (unionIndex895 == 1) { + Utf8 charSequence895; + Object oldString895 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(895); + if (oldString895 instanceof Utf8) { + charSequence895 = (decoder).readString(((Utf8) oldString895)); + } else { + charSequence895 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(895, charSequence895); + } else { + throw new RuntimeException(("Illegal union index for 'F895': "+ unionIndex895)); + } + } + int unionIndex896 = (decoder.readIndex()); + if (unionIndex896 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(896, null); + } else { + if (unionIndex896 == 1) { + Utf8 charSequence896; + Object oldString896 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(896); + if (oldString896 instanceof Utf8) { + charSequence896 = (decoder).readString(((Utf8) oldString896)); + } else { + charSequence896 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(896, charSequence896); + } else { + throw new RuntimeException(("Illegal union index for 'F896': "+ unionIndex896)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex897 = (decoder.readIndex()); + if (unionIndex897 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(897, null); + } else { + if (unionIndex897 == 1) { + Utf8 charSequence897; + Object oldString897 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(897); + if (oldString897 instanceof Utf8) { + charSequence897 = (decoder).readString(((Utf8) oldString897)); + } else { + charSequence897 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(897, charSequence897); + } else { + throw new RuntimeException(("Illegal union index for 'F897': "+ unionIndex897)); + } + } + int unionIndex898 = (decoder.readIndex()); + if (unionIndex898 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(898, null); + } else { + if (unionIndex898 == 1) { + Utf8 charSequence898; + Object oldString898 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(898); + if (oldString898 instanceof Utf8) { + charSequence898 = (decoder).readString(((Utf8) oldString898)); + } else { + charSequence898 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(898, charSequence898); + } else { + throw new RuntimeException(("Illegal union index for 'F898': "+ unionIndex898)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex899 = (decoder.readIndex()); + if (unionIndex899 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(899, null); + } else { + if (unionIndex899 == 1) { + Utf8 charSequence899; + Object oldString899 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(899); + if (oldString899 instanceof Utf8) { + charSequence899 = (decoder).readString(((Utf8) oldString899)); + } else { + charSequence899 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(899, charSequence899); + } else { + throw new RuntimeException(("Illegal union index for 'F899': "+ unionIndex899)); + } + } + int unionIndex900 = (decoder.readIndex()); + if (unionIndex900 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(900, null); + } else { + if (unionIndex900 == 1) { + Utf8 charSequence900; + Object oldString900 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(900); + if (oldString900 instanceof Utf8) { + charSequence900 = (decoder).readString(((Utf8) oldString900)); + } else { + charSequence900 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(900, charSequence900); + } else { + throw new RuntimeException(("Illegal union index for 'F900': "+ unionIndex900)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex901 = (decoder.readIndex()); + if (unionIndex901 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(901, null); + } else { + if (unionIndex901 == 1) { + Utf8 charSequence901; + Object oldString901 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(901); + if (oldString901 instanceof Utf8) { + charSequence901 = (decoder).readString(((Utf8) oldString901)); + } else { + charSequence901 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(901, charSequence901); + } else { + throw new RuntimeException(("Illegal union index for 'F901': "+ unionIndex901)); + } + } + int unionIndex902 = (decoder.readIndex()); + if (unionIndex902 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(902, null); + } else { + if (unionIndex902 == 1) { + Utf8 charSequence902; + Object oldString902 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(902); + if (oldString902 instanceof Utf8) { + charSequence902 = (decoder).readString(((Utf8) oldString902)); + } else { + charSequence902 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(902, charSequence902); + } else { + throw new RuntimeException(("Illegal union index for 'F902': "+ unionIndex902)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex903 = (decoder.readIndex()); + if (unionIndex903 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(903, null); + } else { + if (unionIndex903 == 1) { + Utf8 charSequence903; + Object oldString903 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(903); + if (oldString903 instanceof Utf8) { + charSequence903 = (decoder).readString(((Utf8) oldString903)); + } else { + charSequence903 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(903, charSequence903); + } else { + throw new RuntimeException(("Illegal union index for 'F903': "+ unionIndex903)); + } + } + int unionIndex904 = (decoder.readIndex()); + if (unionIndex904 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(904, null); + } else { + if (unionIndex904 == 1) { + Utf8 charSequence904; + Object oldString904 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(904); + if (oldString904 instanceof Utf8) { + charSequence904 = (decoder).readString(((Utf8) oldString904)); + } else { + charSequence904 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(904, charSequence904); + } else { + throw new RuntimeException(("Illegal union index for 'F904': "+ unionIndex904)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex905 = (decoder.readIndex()); + if (unionIndex905 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(905, null); + } else { + if (unionIndex905 == 1) { + Utf8 charSequence905; + Object oldString905 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(905); + if (oldString905 instanceof Utf8) { + charSequence905 = (decoder).readString(((Utf8) oldString905)); + } else { + charSequence905 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(905, charSequence905); + } else { + throw new RuntimeException(("Illegal union index for 'F905': "+ unionIndex905)); + } + } + int unionIndex906 = (decoder.readIndex()); + if (unionIndex906 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(906, null); + } else { + if (unionIndex906 == 1) { + Utf8 charSequence906; + Object oldString906 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(906); + if (oldString906 instanceof Utf8) { + charSequence906 = (decoder).readString(((Utf8) oldString906)); + } else { + charSequence906 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(906, charSequence906); + } else { + throw new RuntimeException(("Illegal union index for 'F906': "+ unionIndex906)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex907 = (decoder.readIndex()); + if (unionIndex907 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(907, null); + } else { + if (unionIndex907 == 1) { + Utf8 charSequence907; + Object oldString907 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(907); + if (oldString907 instanceof Utf8) { + charSequence907 = (decoder).readString(((Utf8) oldString907)); + } else { + charSequence907 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(907, charSequence907); + } else { + throw new RuntimeException(("Illegal union index for 'F907': "+ unionIndex907)); + } + } + int unionIndex908 = (decoder.readIndex()); + if (unionIndex908 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(908, null); + } else { + if (unionIndex908 == 1) { + Utf8 charSequence908; + Object oldString908 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(908); + if (oldString908 instanceof Utf8) { + charSequence908 = (decoder).readString(((Utf8) oldString908)); + } else { + charSequence908 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(908, charSequence908); + } else { + throw new RuntimeException(("Illegal union index for 'F908': "+ unionIndex908)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex909 = (decoder.readIndex()); + if (unionIndex909 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(909, null); + } else { + if (unionIndex909 == 1) { + Utf8 charSequence909; + Object oldString909 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(909); + if (oldString909 instanceof Utf8) { + charSequence909 = (decoder).readString(((Utf8) oldString909)); + } else { + charSequence909 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(909, charSequence909); + } else { + throw new RuntimeException(("Illegal union index for 'F909': "+ unionIndex909)); + } + } + int unionIndex910 = (decoder.readIndex()); + if (unionIndex910 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(910, null); + } else { + if (unionIndex910 == 1) { + Utf8 charSequence910; + Object oldString910 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(910); + if (oldString910 instanceof Utf8) { + charSequence910 = (decoder).readString(((Utf8) oldString910)); + } else { + charSequence910 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(910, charSequence910); + } else { + throw new RuntimeException(("Illegal union index for 'F910': "+ unionIndex910)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex911 = (decoder.readIndex()); + if (unionIndex911 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(911, null); + } else { + if (unionIndex911 == 1) { + Utf8 charSequence911; + Object oldString911 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(911); + if (oldString911 instanceof Utf8) { + charSequence911 = (decoder).readString(((Utf8) oldString911)); + } else { + charSequence911 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(911, charSequence911); + } else { + throw new RuntimeException(("Illegal union index for 'F911': "+ unionIndex911)); + } + } + int unionIndex912 = (decoder.readIndex()); + if (unionIndex912 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(912, null); + } else { + if (unionIndex912 == 1) { + Utf8 charSequence912; + Object oldString912 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(912); + if (oldString912 instanceof Utf8) { + charSequence912 = (decoder).readString(((Utf8) oldString912)); + } else { + charSequence912 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(912, charSequence912); + } else { + throw new RuntimeException(("Illegal union index for 'F912': "+ unionIndex912)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex913 = (decoder.readIndex()); + if (unionIndex913 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(913, null); + } else { + if (unionIndex913 == 1) { + Utf8 charSequence913; + Object oldString913 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(913); + if (oldString913 instanceof Utf8) { + charSequence913 = (decoder).readString(((Utf8) oldString913)); + } else { + charSequence913 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(913, charSequence913); + } else { + throw new RuntimeException(("Illegal union index for 'F913': "+ unionIndex913)); + } + } + int unionIndex914 = (decoder.readIndex()); + if (unionIndex914 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(914, null); + } else { + if (unionIndex914 == 1) { + Utf8 charSequence914; + Object oldString914 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(914); + if (oldString914 instanceof Utf8) { + charSequence914 = (decoder).readString(((Utf8) oldString914)); + } else { + charSequence914 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(914, charSequence914); + } else { + throw new RuntimeException(("Illegal union index for 'F914': "+ unionIndex914)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex915 = (decoder.readIndex()); + if (unionIndex915 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(915, null); + } else { + if (unionIndex915 == 1) { + Utf8 charSequence915; + Object oldString915 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(915); + if (oldString915 instanceof Utf8) { + charSequence915 = (decoder).readString(((Utf8) oldString915)); + } else { + charSequence915 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(915, charSequence915); + } else { + throw new RuntimeException(("Illegal union index for 'F915': "+ unionIndex915)); + } + } + int unionIndex916 = (decoder.readIndex()); + if (unionIndex916 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(916, null); + } else { + if (unionIndex916 == 1) { + Utf8 charSequence916; + Object oldString916 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(916); + if (oldString916 instanceof Utf8) { + charSequence916 = (decoder).readString(((Utf8) oldString916)); + } else { + charSequence916 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(916, charSequence916); + } else { + throw new RuntimeException(("Illegal union index for 'F916': "+ unionIndex916)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex917 = (decoder.readIndex()); + if (unionIndex917 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(917, null); + } else { + if (unionIndex917 == 1) { + Utf8 charSequence917; + Object oldString917 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(917); + if (oldString917 instanceof Utf8) { + charSequence917 = (decoder).readString(((Utf8) oldString917)); + } else { + charSequence917 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(917, charSequence917); + } else { + throw new RuntimeException(("Illegal union index for 'F917': "+ unionIndex917)); + } + } + int unionIndex918 = (decoder.readIndex()); + if (unionIndex918 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(918, null); + } else { + if (unionIndex918 == 1) { + Utf8 charSequence918; + Object oldString918 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(918); + if (oldString918 instanceof Utf8) { + charSequence918 = (decoder).readString(((Utf8) oldString918)); + } else { + charSequence918 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(918, charSequence918); + } else { + throw new RuntimeException(("Illegal union index for 'F918': "+ unionIndex918)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex919 = (decoder.readIndex()); + if (unionIndex919 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(919, null); + } else { + if (unionIndex919 == 1) { + Utf8 charSequence919; + Object oldString919 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(919); + if (oldString919 instanceof Utf8) { + charSequence919 = (decoder).readString(((Utf8) oldString919)); + } else { + charSequence919 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(919, charSequence919); + } else { + throw new RuntimeException(("Illegal union index for 'F919': "+ unionIndex919)); + } + } + int unionIndex920 = (decoder.readIndex()); + if (unionIndex920 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(920, null); + } else { + if (unionIndex920 == 1) { + Utf8 charSequence920; + Object oldString920 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(920); + if (oldString920 instanceof Utf8) { + charSequence920 = (decoder).readString(((Utf8) oldString920)); + } else { + charSequence920 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(920, charSequence920); + } else { + throw new RuntimeException(("Illegal union index for 'F920': "+ unionIndex920)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex921 = (decoder.readIndex()); + if (unionIndex921 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(921, null); + } else { + if (unionIndex921 == 1) { + Utf8 charSequence921; + Object oldString921 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(921); + if (oldString921 instanceof Utf8) { + charSequence921 = (decoder).readString(((Utf8) oldString921)); + } else { + charSequence921 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(921, charSequence921); + } else { + throw new RuntimeException(("Illegal union index for 'F921': "+ unionIndex921)); + } + } + int unionIndex922 = (decoder.readIndex()); + if (unionIndex922 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(922, null); + } else { + if (unionIndex922 == 1) { + Utf8 charSequence922; + Object oldString922 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(922); + if (oldString922 instanceof Utf8) { + charSequence922 = (decoder).readString(((Utf8) oldString922)); + } else { + charSequence922 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(922, charSequence922); + } else { + throw new RuntimeException(("Illegal union index for 'F922': "+ unionIndex922)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex923 = (decoder.readIndex()); + if (unionIndex923 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(923, null); + } else { + if (unionIndex923 == 1) { + Utf8 charSequence923; + Object oldString923 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(923); + if (oldString923 instanceof Utf8) { + charSequence923 = (decoder).readString(((Utf8) oldString923)); + } else { + charSequence923 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(923, charSequence923); + } else { + throw new RuntimeException(("Illegal union index for 'F923': "+ unionIndex923)); + } + } + int unionIndex924 = (decoder.readIndex()); + if (unionIndex924 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(924, null); + } else { + if (unionIndex924 == 1) { + Utf8 charSequence924; + Object oldString924 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(924); + if (oldString924 instanceof Utf8) { + charSequence924 = (decoder).readString(((Utf8) oldString924)); + } else { + charSequence924 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(924, charSequence924); + } else { + throw new RuntimeException(("Illegal union index for 'F924': "+ unionIndex924)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex925 = (decoder.readIndex()); + if (unionIndex925 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(925, null); + } else { + if (unionIndex925 == 1) { + Utf8 charSequence925; + Object oldString925 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(925); + if (oldString925 instanceof Utf8) { + charSequence925 = (decoder).readString(((Utf8) oldString925)); + } else { + charSequence925 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(925, charSequence925); + } else { + throw new RuntimeException(("Illegal union index for 'F925': "+ unionIndex925)); + } + } + int unionIndex926 = (decoder.readIndex()); + if (unionIndex926 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(926, null); + } else { + if (unionIndex926 == 1) { + Utf8 charSequence926; + Object oldString926 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(926); + if (oldString926 instanceof Utf8) { + charSequence926 = (decoder).readString(((Utf8) oldString926)); + } else { + charSequence926 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(926, charSequence926); + } else { + throw new RuntimeException(("Illegal union index for 'F926': "+ unionIndex926)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex927 = (decoder.readIndex()); + if (unionIndex927 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(927, null); + } else { + if (unionIndex927 == 1) { + Utf8 charSequence927; + Object oldString927 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(927); + if (oldString927 instanceof Utf8) { + charSequence927 = (decoder).readString(((Utf8) oldString927)); + } else { + charSequence927 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(927, charSequence927); + } else { + throw new RuntimeException(("Illegal union index for 'F927': "+ unionIndex927)); + } + } + int unionIndex928 = (decoder.readIndex()); + if (unionIndex928 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(928, null); + } else { + if (unionIndex928 == 1) { + Utf8 charSequence928; + Object oldString928 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(928); + if (oldString928 instanceof Utf8) { + charSequence928 = (decoder).readString(((Utf8) oldString928)); + } else { + charSequence928 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(928, charSequence928); + } else { + throw new RuntimeException(("Illegal union index for 'F928': "+ unionIndex928)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex929 = (decoder.readIndex()); + if (unionIndex929 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(929, null); + } else { + if (unionIndex929 == 1) { + Utf8 charSequence929; + Object oldString929 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(929); + if (oldString929 instanceof Utf8) { + charSequence929 = (decoder).readString(((Utf8) oldString929)); + } else { + charSequence929 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(929, charSequence929); + } else { + throw new RuntimeException(("Illegal union index for 'F929': "+ unionIndex929)); + } + } + int unionIndex930 = (decoder.readIndex()); + if (unionIndex930 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(930, null); + } else { + if (unionIndex930 == 1) { + Utf8 charSequence930; + Object oldString930 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(930); + if (oldString930 instanceof Utf8) { + charSequence930 = (decoder).readString(((Utf8) oldString930)); + } else { + charSequence930 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(930, charSequence930); + } else { + throw new RuntimeException(("Illegal union index for 'F930': "+ unionIndex930)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex931 = (decoder.readIndex()); + if (unionIndex931 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(931, null); + } else { + if (unionIndex931 == 1) { + Utf8 charSequence931; + Object oldString931 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(931); + if (oldString931 instanceof Utf8) { + charSequence931 = (decoder).readString(((Utf8) oldString931)); + } else { + charSequence931 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(931, charSequence931); + } else { + throw new RuntimeException(("Illegal union index for 'F931': "+ unionIndex931)); + } + } + int unionIndex932 = (decoder.readIndex()); + if (unionIndex932 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(932, null); + } else { + if (unionIndex932 == 1) { + Utf8 charSequence932; + Object oldString932 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(932); + if (oldString932 instanceof Utf8) { + charSequence932 = (decoder).readString(((Utf8) oldString932)); + } else { + charSequence932 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(932, charSequence932); + } else { + throw new RuntimeException(("Illegal union index for 'F932': "+ unionIndex932)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex933 = (decoder.readIndex()); + if (unionIndex933 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(933, null); + } else { + if (unionIndex933 == 1) { + Utf8 charSequence933; + Object oldString933 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(933); + if (oldString933 instanceof Utf8) { + charSequence933 = (decoder).readString(((Utf8) oldString933)); + } else { + charSequence933 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(933, charSequence933); + } else { + throw new RuntimeException(("Illegal union index for 'F933': "+ unionIndex933)); + } + } + int unionIndex934 = (decoder.readIndex()); + if (unionIndex934 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(934, null); + } else { + if (unionIndex934 == 1) { + Utf8 charSequence934; + Object oldString934 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(934); + if (oldString934 instanceof Utf8) { + charSequence934 = (decoder).readString(((Utf8) oldString934)); + } else { + charSequence934 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(934, charSequence934); + } else { + throw new RuntimeException(("Illegal union index for 'F934': "+ unionIndex934)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex935 = (decoder.readIndex()); + if (unionIndex935 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(935, null); + } else { + if (unionIndex935 == 1) { + Utf8 charSequence935; + Object oldString935 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(935); + if (oldString935 instanceof Utf8) { + charSequence935 = (decoder).readString(((Utf8) oldString935)); + } else { + charSequence935 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(935, charSequence935); + } else { + throw new RuntimeException(("Illegal union index for 'F935': "+ unionIndex935)); + } + } + int unionIndex936 = (decoder.readIndex()); + if (unionIndex936 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(936, null); + } else { + if (unionIndex936 == 1) { + Utf8 charSequence936; + Object oldString936 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(936); + if (oldString936 instanceof Utf8) { + charSequence936 = (decoder).readString(((Utf8) oldString936)); + } else { + charSequence936 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(936, charSequence936); + } else { + throw new RuntimeException(("Illegal union index for 'F936': "+ unionIndex936)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex937 = (decoder.readIndex()); + if (unionIndex937 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(937, null); + } else { + if (unionIndex937 == 1) { + Utf8 charSequence937; + Object oldString937 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(937); + if (oldString937 instanceof Utf8) { + charSequence937 = (decoder).readString(((Utf8) oldString937)); + } else { + charSequence937 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(937, charSequence937); + } else { + throw new RuntimeException(("Illegal union index for 'F937': "+ unionIndex937)); + } + } + int unionIndex938 = (decoder.readIndex()); + if (unionIndex938 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(938, null); + } else { + if (unionIndex938 == 1) { + Utf8 charSequence938; + Object oldString938 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(938); + if (oldString938 instanceof Utf8) { + charSequence938 = (decoder).readString(((Utf8) oldString938)); + } else { + charSequence938 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(938, charSequence938); + } else { + throw new RuntimeException(("Illegal union index for 'F938': "+ unionIndex938)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex939 = (decoder.readIndex()); + if (unionIndex939 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(939, null); + } else { + if (unionIndex939 == 1) { + Utf8 charSequence939; + Object oldString939 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(939); + if (oldString939 instanceof Utf8) { + charSequence939 = (decoder).readString(((Utf8) oldString939)); + } else { + charSequence939 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(939, charSequence939); + } else { + throw new RuntimeException(("Illegal union index for 'F939': "+ unionIndex939)); + } + } + int unionIndex940 = (decoder.readIndex()); + if (unionIndex940 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(940, null); + } else { + if (unionIndex940 == 1) { + Utf8 charSequence940; + Object oldString940 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(940); + if (oldString940 instanceof Utf8) { + charSequence940 = (decoder).readString(((Utf8) oldString940)); + } else { + charSequence940 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(940, charSequence940); + } else { + throw new RuntimeException(("Illegal union index for 'F940': "+ unionIndex940)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex941 = (decoder.readIndex()); + if (unionIndex941 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(941, null); + } else { + if (unionIndex941 == 1) { + Utf8 charSequence941; + Object oldString941 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(941); + if (oldString941 instanceof Utf8) { + charSequence941 = (decoder).readString(((Utf8) oldString941)); + } else { + charSequence941 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(941, charSequence941); + } else { + throw new RuntimeException(("Illegal union index for 'F941': "+ unionIndex941)); + } + } + int unionIndex942 = (decoder.readIndex()); + if (unionIndex942 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(942, null); + } else { + if (unionIndex942 == 1) { + Utf8 charSequence942; + Object oldString942 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(942); + if (oldString942 instanceof Utf8) { + charSequence942 = (decoder).readString(((Utf8) oldString942)); + } else { + charSequence942 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(942, charSequence942); + } else { + throw new RuntimeException(("Illegal union index for 'F942': "+ unionIndex942)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex943 = (decoder.readIndex()); + if (unionIndex943 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(943, null); + } else { + if (unionIndex943 == 1) { + Utf8 charSequence943; + Object oldString943 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(943); + if (oldString943 instanceof Utf8) { + charSequence943 = (decoder).readString(((Utf8) oldString943)); + } else { + charSequence943 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(943, charSequence943); + } else { + throw new RuntimeException(("Illegal union index for 'F943': "+ unionIndex943)); + } + } + int unionIndex944 = (decoder.readIndex()); + if (unionIndex944 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(944, null); + } else { + if (unionIndex944 == 1) { + Utf8 charSequence944; + Object oldString944 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(944); + if (oldString944 instanceof Utf8) { + charSequence944 = (decoder).readString(((Utf8) oldString944)); + } else { + charSequence944 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(944, charSequence944); + } else { + throw new RuntimeException(("Illegal union index for 'F944': "+ unionIndex944)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex945 = (decoder.readIndex()); + if (unionIndex945 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(945, null); + } else { + if (unionIndex945 == 1) { + Utf8 charSequence945; + Object oldString945 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(945); + if (oldString945 instanceof Utf8) { + charSequence945 = (decoder).readString(((Utf8) oldString945)); + } else { + charSequence945 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(945, charSequence945); + } else { + throw new RuntimeException(("Illegal union index for 'F945': "+ unionIndex945)); + } + } + int unionIndex946 = (decoder.readIndex()); + if (unionIndex946 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(946, null); + } else { + if (unionIndex946 == 1) { + Utf8 charSequence946; + Object oldString946 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(946); + if (oldString946 instanceof Utf8) { + charSequence946 = (decoder).readString(((Utf8) oldString946)); + } else { + charSequence946 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(946, charSequence946); + } else { + throw new RuntimeException(("Illegal union index for 'F946': "+ unionIndex946)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex947 = (decoder.readIndex()); + if (unionIndex947 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(947, null); + } else { + if (unionIndex947 == 1) { + Utf8 charSequence947; + Object oldString947 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(947); + if (oldString947 instanceof Utf8) { + charSequence947 = (decoder).readString(((Utf8) oldString947)); + } else { + charSequence947 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(947, charSequence947); + } else { + throw new RuntimeException(("Illegal union index for 'F947': "+ unionIndex947)); + } + } + int unionIndex948 = (decoder.readIndex()); + if (unionIndex948 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(948, null); + } else { + if (unionIndex948 == 1) { + Utf8 charSequence948; + Object oldString948 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(948); + if (oldString948 instanceof Utf8) { + charSequence948 = (decoder).readString(((Utf8) oldString948)); + } else { + charSequence948 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(948, charSequence948); + } else { + throw new RuntimeException(("Illegal union index for 'F948': "+ unionIndex948)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex949 = (decoder.readIndex()); + if (unionIndex949 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(949, null); + } else { + if (unionIndex949 == 1) { + Utf8 charSequence949; + Object oldString949 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(949); + if (oldString949 instanceof Utf8) { + charSequence949 = (decoder).readString(((Utf8) oldString949)); + } else { + charSequence949 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(949, charSequence949); + } else { + throw new RuntimeException(("Illegal union index for 'F949': "+ unionIndex949)); + } + } + int unionIndex950 = (decoder.readIndex()); + if (unionIndex950 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(950, null); + } else { + if (unionIndex950 == 1) { + Utf8 charSequence950; + Object oldString950 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(950); + if (oldString950 instanceof Utf8) { + charSequence950 = (decoder).readString(((Utf8) oldString950)); + } else { + charSequence950 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(950, charSequence950); + } else { + throw new RuntimeException(("Illegal union index for 'F950': "+ unionIndex950)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex951 = (decoder.readIndex()); + if (unionIndex951 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(951, null); + } else { + if (unionIndex951 == 1) { + Utf8 charSequence951; + Object oldString951 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(951); + if (oldString951 instanceof Utf8) { + charSequence951 = (decoder).readString(((Utf8) oldString951)); + } else { + charSequence951 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(951, charSequence951); + } else { + throw new RuntimeException(("Illegal union index for 'F951': "+ unionIndex951)); + } + } + int unionIndex952 = (decoder.readIndex()); + if (unionIndex952 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(952, null); + } else { + if (unionIndex952 == 1) { + Utf8 charSequence952; + Object oldString952 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(952); + if (oldString952 instanceof Utf8) { + charSequence952 = (decoder).readString(((Utf8) oldString952)); + } else { + charSequence952 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(952, charSequence952); + } else { + throw new RuntimeException(("Illegal union index for 'F952': "+ unionIndex952)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex953 = (decoder.readIndex()); + if (unionIndex953 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(953, null); + } else { + if (unionIndex953 == 1) { + Utf8 charSequence953; + Object oldString953 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(953); + if (oldString953 instanceof Utf8) { + charSequence953 = (decoder).readString(((Utf8) oldString953)); + } else { + charSequence953 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(953, charSequence953); + } else { + throw new RuntimeException(("Illegal union index for 'F953': "+ unionIndex953)); + } + } + int unionIndex954 = (decoder.readIndex()); + if (unionIndex954 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(954, null); + } else { + if (unionIndex954 == 1) { + Utf8 charSequence954; + Object oldString954 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(954); + if (oldString954 instanceof Utf8) { + charSequence954 = (decoder).readString(((Utf8) oldString954)); + } else { + charSequence954 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(954, charSequence954); + } else { + throw new RuntimeException(("Illegal union index for 'F954': "+ unionIndex954)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex955 = (decoder.readIndex()); + if (unionIndex955 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(955, null); + } else { + if (unionIndex955 == 1) { + Utf8 charSequence955; + Object oldString955 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(955); + if (oldString955 instanceof Utf8) { + charSequence955 = (decoder).readString(((Utf8) oldString955)); + } else { + charSequence955 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(955, charSequence955); + } else { + throw new RuntimeException(("Illegal union index for 'F955': "+ unionIndex955)); + } + } + int unionIndex956 = (decoder.readIndex()); + if (unionIndex956 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(956, null); + } else { + if (unionIndex956 == 1) { + Utf8 charSequence956; + Object oldString956 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(956); + if (oldString956 instanceof Utf8) { + charSequence956 = (decoder).readString(((Utf8) oldString956)); + } else { + charSequence956 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(956, charSequence956); + } else { + throw new RuntimeException(("Illegal union index for 'F956': "+ unionIndex956)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex957 = (decoder.readIndex()); + if (unionIndex957 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(957, null); + } else { + if (unionIndex957 == 1) { + Utf8 charSequence957; + Object oldString957 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(957); + if (oldString957 instanceof Utf8) { + charSequence957 = (decoder).readString(((Utf8) oldString957)); + } else { + charSequence957 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(957, charSequence957); + } else { + throw new RuntimeException(("Illegal union index for 'F957': "+ unionIndex957)); + } + } + int unionIndex958 = (decoder.readIndex()); + if (unionIndex958 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(958, null); + } else { + if (unionIndex958 == 1) { + Utf8 charSequence958; + Object oldString958 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(958); + if (oldString958 instanceof Utf8) { + charSequence958 = (decoder).readString(((Utf8) oldString958)); + } else { + charSequence958 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(958, charSequence958); + } else { + throw new RuntimeException(("Illegal union index for 'F958': "+ unionIndex958)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex959 = (decoder.readIndex()); + if (unionIndex959 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(959, null); + } else { + if (unionIndex959 == 1) { + Utf8 charSequence959; + Object oldString959 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(959); + if (oldString959 instanceof Utf8) { + charSequence959 = (decoder).readString(((Utf8) oldString959)); + } else { + charSequence959 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(959, charSequence959); + } else { + throw new RuntimeException(("Illegal union index for 'F959': "+ unionIndex959)); + } + } + int unionIndex960 = (decoder.readIndex()); + if (unionIndex960 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(960, null); + } else { + if (unionIndex960 == 1) { + Utf8 charSequence960; + Object oldString960 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(960); + if (oldString960 instanceof Utf8) { + charSequence960 = (decoder).readString(((Utf8) oldString960)); + } else { + charSequence960 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(960, charSequence960); + } else { + throw new RuntimeException(("Illegal union index for 'F960': "+ unionIndex960)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex961 = (decoder.readIndex()); + if (unionIndex961 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(961, null); + } else { + if (unionIndex961 == 1) { + Utf8 charSequence961; + Object oldString961 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(961); + if (oldString961 instanceof Utf8) { + charSequence961 = (decoder).readString(((Utf8) oldString961)); + } else { + charSequence961 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(961, charSequence961); + } else { + throw new RuntimeException(("Illegal union index for 'F961': "+ unionIndex961)); + } + } + int unionIndex962 = (decoder.readIndex()); + if (unionIndex962 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(962, null); + } else { + if (unionIndex962 == 1) { + Utf8 charSequence962; + Object oldString962 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(962); + if (oldString962 instanceof Utf8) { + charSequence962 = (decoder).readString(((Utf8) oldString962)); + } else { + charSequence962 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(962, charSequence962); + } else { + throw new RuntimeException(("Illegal union index for 'F962': "+ unionIndex962)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex963 = (decoder.readIndex()); + if (unionIndex963 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(963, null); + } else { + if (unionIndex963 == 1) { + Utf8 charSequence963; + Object oldString963 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(963); + if (oldString963 instanceof Utf8) { + charSequence963 = (decoder).readString(((Utf8) oldString963)); + } else { + charSequence963 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(963, charSequence963); + } else { + throw new RuntimeException(("Illegal union index for 'F963': "+ unionIndex963)); + } + } + int unionIndex964 = (decoder.readIndex()); + if (unionIndex964 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(964, null); + } else { + if (unionIndex964 == 1) { + Utf8 charSequence964; + Object oldString964 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(964); + if (oldString964 instanceof Utf8) { + charSequence964 = (decoder).readString(((Utf8) oldString964)); + } else { + charSequence964 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(964, charSequence964); + } else { + throw new RuntimeException(("Illegal union index for 'F964': "+ unionIndex964)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex965 = (decoder.readIndex()); + if (unionIndex965 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(965, null); + } else { + if (unionIndex965 == 1) { + Utf8 charSequence965; + Object oldString965 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(965); + if (oldString965 instanceof Utf8) { + charSequence965 = (decoder).readString(((Utf8) oldString965)); + } else { + charSequence965 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(965, charSequence965); + } else { + throw new RuntimeException(("Illegal union index for 'F965': "+ unionIndex965)); + } + } + int unionIndex966 = (decoder.readIndex()); + if (unionIndex966 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(966, null); + } else { + if (unionIndex966 == 1) { + Utf8 charSequence966; + Object oldString966 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(966); + if (oldString966 instanceof Utf8) { + charSequence966 = (decoder).readString(((Utf8) oldString966)); + } else { + charSequence966 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(966, charSequence966); + } else { + throw new RuntimeException(("Illegal union index for 'F966': "+ unionIndex966)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex967 = (decoder.readIndex()); + if (unionIndex967 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(967, null); + } else { + if (unionIndex967 == 1) { + Utf8 charSequence967; + Object oldString967 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(967); + if (oldString967 instanceof Utf8) { + charSequence967 = (decoder).readString(((Utf8) oldString967)); + } else { + charSequence967 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(967, charSequence967); + } else { + throw new RuntimeException(("Illegal union index for 'F967': "+ unionIndex967)); + } + } + int unionIndex968 = (decoder.readIndex()); + if (unionIndex968 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(968, null); + } else { + if (unionIndex968 == 1) { + Utf8 charSequence968; + Object oldString968 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(968); + if (oldString968 instanceof Utf8) { + charSequence968 = (decoder).readString(((Utf8) oldString968)); + } else { + charSequence968 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(968, charSequence968); + } else { + throw new RuntimeException(("Illegal union index for 'F968': "+ unionIndex968)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex969 = (decoder.readIndex()); + if (unionIndex969 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(969, null); + } else { + if (unionIndex969 == 1) { + Utf8 charSequence969; + Object oldString969 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(969); + if (oldString969 instanceof Utf8) { + charSequence969 = (decoder).readString(((Utf8) oldString969)); + } else { + charSequence969 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(969, charSequence969); + } else { + throw new RuntimeException(("Illegal union index for 'F969': "+ unionIndex969)); + } + } + int unionIndex970 = (decoder.readIndex()); + if (unionIndex970 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(970, null); + } else { + if (unionIndex970 == 1) { + Utf8 charSequence970; + Object oldString970 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(970); + if (oldString970 instanceof Utf8) { + charSequence970 = (decoder).readString(((Utf8) oldString970)); + } else { + charSequence970 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(970, charSequence970); + } else { + throw new RuntimeException(("Illegal union index for 'F970': "+ unionIndex970)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex971 = (decoder.readIndex()); + if (unionIndex971 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(971, null); + } else { + if (unionIndex971 == 1) { + Utf8 charSequence971; + Object oldString971 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(971); + if (oldString971 instanceof Utf8) { + charSequence971 = (decoder).readString(((Utf8) oldString971)); + } else { + charSequence971 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(971, charSequence971); + } else { + throw new RuntimeException(("Illegal union index for 'F971': "+ unionIndex971)); + } + } + int unionIndex972 = (decoder.readIndex()); + if (unionIndex972 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(972, null); + } else { + if (unionIndex972 == 1) { + Utf8 charSequence972; + Object oldString972 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(972); + if (oldString972 instanceof Utf8) { + charSequence972 = (decoder).readString(((Utf8) oldString972)); + } else { + charSequence972 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(972, charSequence972); + } else { + throw new RuntimeException(("Illegal union index for 'F972': "+ unionIndex972)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex973 = (decoder.readIndex()); + if (unionIndex973 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(973, null); + } else { + if (unionIndex973 == 1) { + Utf8 charSequence973; + Object oldString973 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(973); + if (oldString973 instanceof Utf8) { + charSequence973 = (decoder).readString(((Utf8) oldString973)); + } else { + charSequence973 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(973, charSequence973); + } else { + throw new RuntimeException(("Illegal union index for 'F973': "+ unionIndex973)); + } + } + int unionIndex974 = (decoder.readIndex()); + if (unionIndex974 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(974, null); + } else { + if (unionIndex974 == 1) { + Utf8 charSequence974; + Object oldString974 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(974); + if (oldString974 instanceof Utf8) { + charSequence974 = (decoder).readString(((Utf8) oldString974)); + } else { + charSequence974 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(974, charSequence974); + } else { + throw new RuntimeException(("Illegal union index for 'F974': "+ unionIndex974)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex975 = (decoder.readIndex()); + if (unionIndex975 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(975, null); + } else { + if (unionIndex975 == 1) { + Utf8 charSequence975; + Object oldString975 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(975); + if (oldString975 instanceof Utf8) { + charSequence975 = (decoder).readString(((Utf8) oldString975)); + } else { + charSequence975 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(975, charSequence975); + } else { + throw new RuntimeException(("Illegal union index for 'F975': "+ unionIndex975)); + } + } + int unionIndex976 = (decoder.readIndex()); + if (unionIndex976 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(976, null); + } else { + if (unionIndex976 == 1) { + Utf8 charSequence976; + Object oldString976 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(976); + if (oldString976 instanceof Utf8) { + charSequence976 = (decoder).readString(((Utf8) oldString976)); + } else { + charSequence976 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(976, charSequence976); + } else { + throw new RuntimeException(("Illegal union index for 'F976': "+ unionIndex976)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex977 = (decoder.readIndex()); + if (unionIndex977 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(977, null); + } else { + if (unionIndex977 == 1) { + Utf8 charSequence977; + Object oldString977 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(977); + if (oldString977 instanceof Utf8) { + charSequence977 = (decoder).readString(((Utf8) oldString977)); + } else { + charSequence977 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(977, charSequence977); + } else { + throw new RuntimeException(("Illegal union index for 'F977': "+ unionIndex977)); + } + } + int unionIndex978 = (decoder.readIndex()); + if (unionIndex978 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(978, null); + } else { + if (unionIndex978 == 1) { + Utf8 charSequence978; + Object oldString978 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(978); + if (oldString978 instanceof Utf8) { + charSequence978 = (decoder).readString(((Utf8) oldString978)); + } else { + charSequence978 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(978, charSequence978); + } else { + throw new RuntimeException(("Illegal union index for 'F978': "+ unionIndex978)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex979 = (decoder.readIndex()); + if (unionIndex979 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(979, null); + } else { + if (unionIndex979 == 1) { + Utf8 charSequence979; + Object oldString979 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(979); + if (oldString979 instanceof Utf8) { + charSequence979 = (decoder).readString(((Utf8) oldString979)); + } else { + charSequence979 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(979, charSequence979); + } else { + throw new RuntimeException(("Illegal union index for 'F979': "+ unionIndex979)); + } + } + int unionIndex980 = (decoder.readIndex()); + if (unionIndex980 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(980, null); + } else { + if (unionIndex980 == 1) { + Utf8 charSequence980; + Object oldString980 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(980); + if (oldString980 instanceof Utf8) { + charSequence980 = (decoder).readString(((Utf8) oldString980)); + } else { + charSequence980 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(980, charSequence980); + } else { + throw new RuntimeException(("Illegal union index for 'F980': "+ unionIndex980)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex981 = (decoder.readIndex()); + if (unionIndex981 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(981, null); + } else { + if (unionIndex981 == 1) { + Utf8 charSequence981; + Object oldString981 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(981); + if (oldString981 instanceof Utf8) { + charSequence981 = (decoder).readString(((Utf8) oldString981)); + } else { + charSequence981 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(981, charSequence981); + } else { + throw new RuntimeException(("Illegal union index for 'F981': "+ unionIndex981)); + } + } + int unionIndex982 = (decoder.readIndex()); + if (unionIndex982 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(982, null); + } else { + if (unionIndex982 == 1) { + Utf8 charSequence982; + Object oldString982 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(982); + if (oldString982 instanceof Utf8) { + charSequence982 = (decoder).readString(((Utf8) oldString982)); + } else { + charSequence982 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(982, charSequence982); + } else { + throw new RuntimeException(("Illegal union index for 'F982': "+ unionIndex982)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex983 = (decoder.readIndex()); + if (unionIndex983 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(983, null); + } else { + if (unionIndex983 == 1) { + Utf8 charSequence983; + Object oldString983 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(983); + if (oldString983 instanceof Utf8) { + charSequence983 = (decoder).readString(((Utf8) oldString983)); + } else { + charSequence983 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(983, charSequence983); + } else { + throw new RuntimeException(("Illegal union index for 'F983': "+ unionIndex983)); + } + } + int unionIndex984 = (decoder.readIndex()); + if (unionIndex984 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(984, null); + } else { + if (unionIndex984 == 1) { + Utf8 charSequence984; + Object oldString984 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(984); + if (oldString984 instanceof Utf8) { + charSequence984 = (decoder).readString(((Utf8) oldString984)); + } else { + charSequence984 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(984, charSequence984); + } else { + throw new RuntimeException(("Illegal union index for 'F984': "+ unionIndex984)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex985 = (decoder.readIndex()); + if (unionIndex985 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(985, null); + } else { + if (unionIndex985 == 1) { + Utf8 charSequence985; + Object oldString985 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(985); + if (oldString985 instanceof Utf8) { + charSequence985 = (decoder).readString(((Utf8) oldString985)); + } else { + charSequence985 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(985, charSequence985); + } else { + throw new RuntimeException(("Illegal union index for 'F985': "+ unionIndex985)); + } + } + int unionIndex986 = (decoder.readIndex()); + if (unionIndex986 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(986, null); + } else { + if (unionIndex986 == 1) { + Utf8 charSequence986; + Object oldString986 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(986); + if (oldString986 instanceof Utf8) { + charSequence986 = (decoder).readString(((Utf8) oldString986)); + } else { + charSequence986 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(986, charSequence986); + } else { + throw new RuntimeException(("Illegal union index for 'F986': "+ unionIndex986)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex987 = (decoder.readIndex()); + if (unionIndex987 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(987, null); + } else { + if (unionIndex987 == 1) { + Utf8 charSequence987; + Object oldString987 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(987); + if (oldString987 instanceof Utf8) { + charSequence987 = (decoder).readString(((Utf8) oldString987)); + } else { + charSequence987 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(987, charSequence987); + } else { + throw new RuntimeException(("Illegal union index for 'F987': "+ unionIndex987)); + } + } + int unionIndex988 = (decoder.readIndex()); + if (unionIndex988 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(988, null); + } else { + if (unionIndex988 == 1) { + Utf8 charSequence988; + Object oldString988 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(988); + if (oldString988 instanceof Utf8) { + charSequence988 = (decoder).readString(((Utf8) oldString988)); + } else { + charSequence988 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(988, charSequence988); + } else { + throw new RuntimeException(("Illegal union index for 'F988': "+ unionIndex988)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex989 = (decoder.readIndex()); + if (unionIndex989 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(989, null); + } else { + if (unionIndex989 == 1) { + Utf8 charSequence989; + Object oldString989 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(989); + if (oldString989 instanceof Utf8) { + charSequence989 = (decoder).readString(((Utf8) oldString989)); + } else { + charSequence989 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(989, charSequence989); + } else { + throw new RuntimeException(("Illegal union index for 'F989': "+ unionIndex989)); + } + } + int unionIndex990 = (decoder.readIndex()); + if (unionIndex990 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(990, null); + } else { + if (unionIndex990 == 1) { + Utf8 charSequence990; + Object oldString990 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(990); + if (oldString990 instanceof Utf8) { + charSequence990 = (decoder).readString(((Utf8) oldString990)); + } else { + charSequence990 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(990, charSequence990); + } else { + throw new RuntimeException(("Illegal union index for 'F990': "+ unionIndex990)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex991 = (decoder.readIndex()); + if (unionIndex991 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(991, null); + } else { + if (unionIndex991 == 1) { + Utf8 charSequence991; + Object oldString991 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(991); + if (oldString991 instanceof Utf8) { + charSequence991 = (decoder).readString(((Utf8) oldString991)); + } else { + charSequence991 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(991, charSequence991); + } else { + throw new RuntimeException(("Illegal union index for 'F991': "+ unionIndex991)); + } + } + int unionIndex992 = (decoder.readIndex()); + if (unionIndex992 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(992, null); + } else { + if (unionIndex992 == 1) { + Utf8 charSequence992; + Object oldString992 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(992); + if (oldString992 instanceof Utf8) { + charSequence992 = (decoder).readString(((Utf8) oldString992)); + } else { + charSequence992 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(992, charSequence992); + } else { + throw new RuntimeException(("Illegal union index for 'F992': "+ unionIndex992)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex993 = (decoder.readIndex()); + if (unionIndex993 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(993, null); + } else { + if (unionIndex993 == 1) { + Utf8 charSequence993; + Object oldString993 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(993); + if (oldString993 instanceof Utf8) { + charSequence993 = (decoder).readString(((Utf8) oldString993)); + } else { + charSequence993 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(993, charSequence993); + } else { + throw new RuntimeException(("Illegal union index for 'F993': "+ unionIndex993)); + } + } + int unionIndex994 = (decoder.readIndex()); + if (unionIndex994 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(994, null); + } else { + if (unionIndex994 == 1) { + Utf8 charSequence994; + Object oldString994 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(994); + if (oldString994 instanceof Utf8) { + charSequence994 = (decoder).readString(((Utf8) oldString994)); + } else { + charSequence994 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(994, charSequence994); + } else { + throw new RuntimeException(("Illegal union index for 'F994': "+ unionIndex994)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex995 = (decoder.readIndex()); + if (unionIndex995 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(995, null); + } else { + if (unionIndex995 == 1) { + Utf8 charSequence995; + Object oldString995 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(995); + if (oldString995 instanceof Utf8) { + charSequence995 = (decoder).readString(((Utf8) oldString995)); + } else { + charSequence995 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(995, charSequence995); + } else { + throw new RuntimeException(("Illegal union index for 'F995': "+ unionIndex995)); + } + } + int unionIndex996 = (decoder.readIndex()); + if (unionIndex996 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(996, null); + } else { + if (unionIndex996 == 1) { + Utf8 charSequence996; + Object oldString996 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(996); + if (oldString996 instanceof Utf8) { + charSequence996 = (decoder).readString(((Utf8) oldString996)); + } else { + charSequence996 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(996, charSequence996); + } else { + throw new RuntimeException(("Illegal union index for 'F996': "+ unionIndex996)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex997 = (decoder.readIndex()); + if (unionIndex997 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(997, null); + } else { + if (unionIndex997 == 1) { + Utf8 charSequence997; + Object oldString997 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(997); + if (oldString997 instanceof Utf8) { + charSequence997 = (decoder).readString(((Utf8) oldString997)); + } else { + charSequence997 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(997, charSequence997); + } else { + throw new RuntimeException(("Illegal union index for 'F997': "+ unionIndex997)); + } + } + int unionIndex998 = (decoder.readIndex()); + if (unionIndex998 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(998, null); + } else { + if (unionIndex998 == 1) { + Utf8 charSequence998; + Object oldString998 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(998); + if (oldString998 instanceof Utf8) { + charSequence998 = (decoder).readString(((Utf8) oldString998)); + } else { + charSequence998 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(998, charSequence998); + } else { + throw new RuntimeException(("Illegal union index for 'F998': "+ unionIndex998)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex999 = (decoder.readIndex()); + if (unionIndex999 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(999, null); + } else { + if (unionIndex999 == 1) { + Utf8 charSequence999; + Object oldString999 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(999); + if (oldString999 instanceof Utf8) { + charSequence999 = (decoder).readString(((Utf8) oldString999)); + } else { + charSequence999 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(999, charSequence999); + } else { + throw new RuntimeException(("Illegal union index for 'F999': "+ unionIndex999)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java new file mode 100644 index 000000000..87ddf1dc8 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testString0; + private final Schema testStringUnionAlias0; + + public FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testString0 = readerSchema.getField("testString").schema(); + this.testStringUnionAlias0 = readerSchema.getField("testStringUnionAlias").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadAliasedField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadAliasedField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadAliasedField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadAliasedField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadAliasedField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldReadAliasedField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'testString': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0((FastGenericDeserializerGeneratorTest_shouldReadAliasedField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadAliasedField; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadAliasedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(1, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadAliasedField.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnionAlias': "+ unionIndex1)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java new file mode 100644 index 000000000..4c0c0d382 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java @@ -0,0 +1,122 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Schema testEnumUnion0; + private final Schema testEnumArray0; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadEnum = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadEnum = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(0, new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get((decoder.readEnum())))); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum1((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(1, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(1, new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get((decoder.readEnum())))); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadEnum.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + testEnumArray1 .clear(); + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadEnum.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + testEnumUnionArray1 .clear(); + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testFixed0; + private final Schema testFixedUnion0; + private final Schema testFixedArray0; + private final Schema testFixedUnionArray0; + private final Schema testFixedUnionArrayArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadFixed_GenericDeserializer_1590965143_1590965143(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testFixed0 = readerSchema.getField("testFixed").schema(); + this.testFixedUnion0 = readerSchema.getField("testFixedUnion").schema(); + this.testFixedArray0 = readerSchema.getField("testFixedArray").schema(); + this.testFixedUnionArray0 = readerSchema.getField("testFixedUnionArray").schema(); + this.testFixedUnionArrayArrayElemSchema0 = testFixedUnionArray0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadFixed = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadFixed = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + byte[] testFixed1; + Object oldFixed0 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(0); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (2))) { + testFixed1 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed1 = ( new byte[2]); + } + decoder.readFixed(testFixed1); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(0, new org.apache.avro.generic.GenericData.Fixed(testFixed0, testFixed1)); + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed1((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadFixed; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(1, null); + } else { + if (unionIndex0 == 1) { + byte[] testFixed2; + Object oldFixed1 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(1); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (2))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[2]); + } + decoder.readFixed(testFixed2); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(1, new org.apache.avro.generic.GenericData.Fixed(testFixed0, testFixed2)); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex0)); + } + } + List testFixedArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(2); + if (oldArray0 instanceof List) { + testFixedArray1 = ((List) oldArray0); + testFixedArray1 .clear(); + } else { + testFixedArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testFixedArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(3); + if (oldArray1 instanceof List) { + testFixedUnionArray1 = ((List) oldArray1); + testFixedUnionArray1 .clear(); + } else { + testFixedUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testFixedUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema union0; + private final Schema unionOptionSchema0; + private final Schema subField0; + + public FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion_GenericDeserializer_2643982_2643982(Schema readerSchema) { + this.readerSchema = readerSchema; + this.union0 = readerSchema.getField("union").schema(); + this.unionOptionSchema0 = union0 .getTypes().get(1); + this.subField0 = unionOptionSchema0 .getField("subField").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, charSequence1); + } else { + if (unionIndex0 == 3) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + } + return FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == unionOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(unionOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java new file mode 100644 index 000000000..5ad3bab08 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java @@ -0,0 +1,129 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema mapField0; + private final Schema mapFieldMapValueSchema0; + private final Schema mapFieldValueMapValueSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapField0 = readerSchema.getField("mapField").schema(); + this.mapFieldMapValueSchema0 = mapField0 .getValueType(); + this.mapFieldValueMapValueSchema0 = mapFieldMapValueSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadNestedMap; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadNestedMap = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadNestedMap = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map>> mapField1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), ((int) chunkLen0))); + } else { + Map>> mapFieldReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0); + if (oldMap0 instanceof Map) { + mapFieldReuse0 = ((Map) oldMap0); + } + if (mapFieldReuse0 != (null)) { + mapFieldReuse0 .clear(); + mapField1 = mapFieldReuse0; + } else { + mapField1 = new HashMap>>(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 > mapFieldValue0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, ((int) chunkLen1))); + } else { + Map> mapFieldValueReuse0 = null; + if (null instanceof Map) { + mapFieldValueReuse0 = ((Map) null); + } + if (mapFieldValueReuse0 != (null)) { + mapFieldValueReuse0 .clear(); + mapFieldValue0 = mapFieldValueReuse0; + } else { + mapFieldValue0 = new HashMap>(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0) { + for (int counter2 = 0; (counter2 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, 0)); + } else { + mapFieldValue0 = new HashMap>(0); + } + } + mapField1 .put(key0, mapFieldValue0); + } + chunkLen0 = (decoder.mapNext()); + } while (chunkLen0 > 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), 0)); + } else { + mapField1 = new HashMap>>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadNestedMap.put(0, mapField1); + return FastGenericDeserializerGeneratorTest_shouldReadNestedMap; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java new file mode 100644 index 000000000..2ea455f6d --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java @@ -0,0 +1,206 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + private final Schema testEnumUnion0; + private final Map enumMappingtestEnum1; + private final Schema testEnumArray0; + private final Map enumMappingtestEnum2; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + private final Map enumMappingtestEnum3; + + public FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(5); + tempEnumMapping0 .put(new Integer(0), new Integer(1)); + tempEnumMapping0 .put(new Integer(1), new Integer(0)); + tempEnumMapping0 .put(new Integer(2), new Integer(4)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + HashMap tempEnumMapping1 = new HashMap(5); + tempEnumMapping1 .put(new Integer(0), new Integer(1)); + tempEnumMapping1 .put(new Integer(1), new Integer(0)); + tempEnumMapping1 .put(new Integer(2), new Integer(4)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + HashMap tempEnumMapping2 = new HashMap(5); + tempEnumMapping2 .put(new Integer(0), new Integer(1)); + tempEnumMapping2 .put(new Integer(1), new Integer(0)); + tempEnumMapping2 .put(new Integer(2), new Integer(4)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + HashMap tempEnumMapping3 = new HashMap(5); + tempEnumMapping3 .put(new Integer(0), new Integer(1)); + tempEnumMapping3 .put(new Integer(1), new Integer(0)); + tempEnumMapping3 .put(new Integer(2), new Integer(4)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(0, enumValue0); + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum1((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(1, null); + } else { + if (unionIndex0 == 1) { + int enumIndex1 = (decoder.readEnum()); + GenericEnumSymbol enumValue1 = null; + Object enumIndexLookupResult1 = enumMappingtestEnum1 .get(enumIndex1); + if (enumIndexLookupResult1 instanceof Integer) { + enumValue1 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult1))); + } else { + if (enumIndexLookupResult1 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult1); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(1, enumValue1); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + testEnumArray1 .clear(); + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + testEnumUnionArray1 .clear(); + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testIntUnion0; + private final Schema testStringUnion0; + private final Schema testLongUnion0; + private final Schema testDoubleUnion0; + private final Schema testFloatUnion0; + private final Schema testBooleanUnion0; + private final Schema testBytesUnion0; + + public FastGenericDeserializerGeneratorTest_shouldReadPrimitives_GenericDeserializer_1966544736_1966544736(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testIntUnion0 = readerSchema.getField("testIntUnion").schema(); + this.testStringUnion0 = readerSchema.getField("testStringUnion").schema(); + this.testLongUnion0 = readerSchema.getField("testLongUnion").schema(); + this.testDoubleUnion0 = readerSchema.getField("testDoubleUnion").schema(); + this.testFloatUnion0 = readerSchema.getField("testFloatUnion").schema(); + this.testBooleanUnion0 = readerSchema.getField("testBooleanUnion").schema(); + this.testBytesUnion0 = readerSchema.getField("testBytesUnion").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(0, (decoder.readInt())); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPrimitives; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(1, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(2); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(2, charSequence0); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(3, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(3); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(3, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(4, (decoder.readLong())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(5, null); + } else { + if (unionIndex2 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(5, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex2)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(6, (decoder.readDouble())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(7, null); + } else { + if (unionIndex3 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(7, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex3)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(8, (decoder.readFloat())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(9, null); + } else { + if (unionIndex4 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(9, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex4)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(10, (decoder.readBoolean())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(11, null); + } else { + if (unionIndex5 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(11, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex5)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(12); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(12, byteBuffer0); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(13, null); + } else { + if (unionIndex6 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(13); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(13, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex6)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java new file mode 100644 index 000000000..32af4443d --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java @@ -0,0 +1,160 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema record10; + private final Schema subField0; + private final Schema intFieldField0; + private final Schema intField0; + private final Schema subField1; + private final Schema recordArray0; + + public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record10 = readerSchema.getField("record1").schema(); + this.subField0 = record10 .getField("subField").schema(); + this.intFieldField0 = record10 .getField("intField").schema(); + this.intField0 = record10 .getField("intField").schema(); + this.subField1 = record10 .getField("subField").schema(); + this.recordArray0 = readerSchema.getField("recordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == record10)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(record10); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + subRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(1); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(1, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex0)); + } + } + subRecord.put(0, null); + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord1(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); + List recordArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); + if (oldArray0 instanceof List) { + recordArray1 = ((List) oldArray0); + recordArray1 .clear(); + } else { + recordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema record10; + private final Schema subField0; + private final Schema record20; + private final Schema intField0; + private final Schema subField1; + private final Schema recordArray0; + + public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1365753944_1274815349(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record10 = readerSchema.getField("record1").schema(); + this.subField0 = record10 .getField("subField").schema(); + this.record20 = readerSchema.getField("record2").schema(); + this.intField0 = record20 .getField("intField").schema(); + this.subField1 = record20 .getField("subField").schema(); + this.recordArray0 = readerSchema.getField("recordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializealiasedSubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializealiasedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord aliasedSubRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == record10)) { + aliasedSubRecord = ((IndexedRecord)(reuse)); + } else { + aliasedSubRecord = new org.apache.avro.generic.GenericData.Record(record10); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + decoder.readInt(); + } else { + throw new RuntimeException(("Illegal union index for 'intField': "+ unionIndex0)); + } + } + populate_aliasedSubRecord0((aliasedSubRecord), (customization), (decoder)); + return aliasedSubRecord; + } + + private void populate_aliasedSubRecord0(IndexedRecord aliasedSubRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + aliasedSubRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = aliasedSubRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + aliasedSubRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); + List recordArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); + if (oldArray0 instanceof List) { + recordArray1 = ((List) oldArray0); + recordArray1 .clear(); + } else { + recordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema recordsArray0; + private final Schema recordsArrayArrayElemSchema0; + private final Schema subField0; + private final Schema recordsMap0; + private final Schema recordsArrayUnion0; + private final Schema recordsArrayUnionOptionSchema0; + private final Schema recordsArrayUnionOptionArrayElemSchema0; + private final Schema recordsMapUnion0; + private final Schema recordsMapUnionOptionSchema0; + private final Schema recordsMapUnionOptionMapValueSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField_GenericDeserializer_1602399407_1602399407(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordsArray0 = readerSchema.getField("recordsArray").schema(); + this.recordsArrayArrayElemSchema0 = recordsArray0 .getElementType(); + this.subField0 = recordsArrayArrayElemSchema0 .getField("subField").schema(); + this.recordsMap0 = readerSchema.getField("recordsMap").schema(); + this.recordsArrayUnion0 = readerSchema.getField("recordsArrayUnion").schema(); + this.recordsArrayUnionOptionSchema0 = recordsArrayUnion0 .getTypes().get(1); + this.recordsArrayUnionOptionArrayElemSchema0 = recordsArrayUnionOptionSchema0 .getElementType(); + this.recordsMapUnion0 = readerSchema.getField("recordsMapUnion").schema(); + this.recordsMapUnionOptionSchema0 = recordsMapUnion0 .getTypes().get(1); + this.recordsMapUnionOptionMapValueSchema0 = recordsMapUnionOptionSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List recordsArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(0); + if (oldArray0 instanceof List) { + recordsArray1 = ((List) oldArray0); + recordsArray1 .clear(); + } else { + recordsArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordsArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 recordsMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), ((int) chunkLen1))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap1 = recordsMapReuse0; + } else { + recordsMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), 0)); + } else { + recordsMap1 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(1, recordsMap1); + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(2, null); + } else { + if (unionIndex1 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(2); + if (oldArray1 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray1); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen2), recordsArrayUnionOptionSchema0); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 recordsMapUnionOption0 = null; + long chunkLen3 = (decoder.readMapStart()); + if (chunkLen3 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), ((int) chunkLen3))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); + } + } + do { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(3, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex3)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java new file mode 100644 index 000000000..6b47ada2c --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java @@ -0,0 +1,378 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema recordsArrayMap0; + private final Schema recordsArrayMapArrayElemSchema0; + private final Schema recordsArrayMapElemMapValueSchema0; + private final Schema recordsArrayMapElemValueOptionSchema0; + private final Schema subField0; + private final Schema recordsMapArray0; + private final Schema recordsMapArrayMapValueSchema0; + private final Schema recordsMapArrayValueArrayElemSchema0; + private final Schema recordsArrayMapUnion0; + private final Schema recordsArrayMapUnionOptionArrayElemSchema0; + private final Schema recordsArrayMapUnionOptionElemMapValueSchema0; + private final Schema recordsMapArrayUnion0; + private final Schema recordsMapArrayUnionOptionSchema0; + private final Schema recordsMapArrayUnionOptionValueArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordsArrayMap0 = readerSchema.getField("recordsArrayMap").schema(); + this.recordsArrayMapArrayElemSchema0 = recordsArrayMap0 .getElementType(); + this.recordsArrayMapElemMapValueSchema0 = recordsArrayMapArrayElemSchema0 .getValueType(); + this.recordsArrayMapElemValueOptionSchema0 = recordsArrayMapElemMapValueSchema0 .getTypes().get(1); + this.subField0 = recordsArrayMapElemValueOptionSchema0 .getField("subField").schema(); + this.recordsMapArray0 = readerSchema.getField("recordsMapArray").schema(); + this.recordsMapArrayMapValueSchema0 = recordsMapArray0 .getValueType(); + this.recordsMapArrayValueArrayElemSchema0 = recordsMapArrayMapValueSchema0 .getElementType(); + this.recordsArrayMapUnion0 = readerSchema.getField("recordsArrayMapUnion").schema(); + this.recordsArrayMapUnionOptionArrayElemSchema0 = recordsArrayMap0 .getElementType(); + this.recordsArrayMapUnionOptionElemMapValueSchema0 = recordsArrayMapUnionOptionArrayElemSchema0 .getValueType(); + this.recordsMapArrayUnion0 = readerSchema.getField("recordsMapArrayUnion").schema(); + this.recordsMapArrayUnionOptionSchema0 = recordsMapArrayUnion0 .getTypes().get(1); + this.recordsMapArrayUnionOptionValueArrayElemSchema0 = recordsMapArrayMapValueSchema0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List> recordsArrayMap1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(0); + if (oldArray0 instanceof List) { + recordsArrayMap1 = ((List) oldArray0); + recordsArrayMap1 .clear(); + } else { + recordsArrayMap1 = new org.apache.avro.generic.GenericData.Array>(((int) chunkLen0), recordsArrayMap0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 recordsArrayMapElem0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen1))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap1 .add(recordsArrayMapElem0); + } + chunkLen0 = (decoder.arrayNext()); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(0, recordsArrayMap1); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordsArrayMapElemValueOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(recordsArrayMapElemValueOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray1 = null; + long chunkLen2 = (decoder.readMapStart()); + if (chunkLen2 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), ((int) chunkLen2))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap0); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray1 = recordsMapArrayReuse0; + } else { + recordsMapArray1 = new HashMap>(((int)(((chunkLen2 * 4)+ 2)/ 3))); + } + } + do { + for (int counter2 = 0; (counter2 recordsMapArrayValue0 = null; + long chunkLen3 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen3), recordsMapArrayMapValueSchema0); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), 0)); + } else { + recordsMapArray1 = new HashMap>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(1, recordsMapArray1); + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(2, null); + } else { + if (unionIndex3 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(2); + if (oldArray1 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray1); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new org.apache.avro.generic.GenericData.Array>(((int) chunkLen4), recordsArrayMap0); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArrayMapUnionOptionElem0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen5))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen4 = (decoder.arrayNext()); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(2, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex3)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(3, null); + } else { + if (unionIndex5 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), ((int) chunkLen6))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 recordsMapArrayUnionOptionValue0 = null; + long chunkLen7 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen7), recordsMapArrayMapValueSchema0); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(3, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex5)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java new file mode 100644 index 000000000..d6650febb --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java @@ -0,0 +1,114 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema record0; + private final Schema recordOptionSchema0; + private final Schema subField0; + private final Schema field0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record0 = readerSchema.getField("record").schema(); + this.recordOptionSchema0 = record0 .getTypes().get(1); + this.subField0 = recordOptionSchema0 .getField("subField").schema(); + this.field0 = readerSchema.getField("field").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'record': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(recordOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(1), (decoder), (customization))); + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(2, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(2); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(2, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex2)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java new file mode 100644 index 000000000..c9d3d75a3 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java @@ -0,0 +1,252 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testNotRemoved0; + private final Schema testNotRemoved20; + private final Schema subRecord0; + private final Schema subRecordOptionSchema0; + private final Schema testNotRemoved1; + private final Schema testNotRemoved21; + private final Schema subRecordMap0; + private final Schema subRecordArray0; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testNotRemoved0 = readerSchema.getField("testNotRemoved").schema(); + this.testNotRemoved20 = readerSchema.getField("testNotRemoved2").schema(); + this.subRecord0 = readerSchema.getField("subRecord").schema(); + this.subRecordOptionSchema0 = subRecord0 .getTypes().get(1); + this.testNotRemoved1 = subRecordOptionSchema0 .getField("testNotRemoved").schema(); + this.testNotRemoved21 = subRecordOptionSchema0 .getField("testNotRemoved2").schema(); + this.subRecordMap0 = readerSchema.getField("subRecordMap").schema(); + this.subRecordArray0 = readerSchema.getField("subRecordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + } else { + if (unionIndex1 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testRemoved': "+ unionIndex1)); + } + } + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(1, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved2': "+ unionIndex2)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, null); + } else { + if (unionIndex3 == 1) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(2), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex3)); + } + } + Map subRecordMap1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), ((int) chunkLen0))); + } else { + Map subRecordMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3); + if (oldMap0 instanceof Map) { + subRecordMapReuse0 = ((Map) oldMap0); + } + if (subRecordMapReuse0 != (null)) { + subRecordMapReuse0 .clear(); + subRecordMap1 = subRecordMapReuse0; + } else { + subRecordMap1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), 0)); + } else { + subRecordMap1 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(3, subRecordMap1); + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecordOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecordOptionSchema0); + } + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex4 == 1) { + Utf8 charSequence2; + Object oldString2 = subRecord.get(0); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + subRecord.put(0, charSequence2); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex4)); + } + } + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + } else { + if (unionIndex5 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testRemoved': "+ unionIndex5)); + } + } + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + subRecord.put(1, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence3; + Object oldString3 = subRecord.get(1); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + subRecord.put(1, charSequence3); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved2': "+ unionIndex6)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List subRecordArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(4); + if (oldArray0 instanceof List) { + subRecordArray1 = ((List) oldArray0); + subRecordArray1 .clear(); + } else { + subRecordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), subRecordArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema subRecord0; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord_GenericDeserializer_1090641932_438987109(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.get(0), (decoder), (customization))); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord0); + } + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + populate_subRecord0((subRecord), (customization), (decoder)); + populate_subRecord1((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubSubRecord0(null, (decoder), (customization)); + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + deserializesubSubRecord0(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'test3': "+ unionIndex0)); + } + } + } + + public void deserializesubSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + populate_subSubRecord0((decoder)); + } + + private void populate_subSubRecord0(Decoder decoder) + throws IOException + { + decoder.skipString(); + } + + private void populate_subRecord1(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = subRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + subRecord.put(1, charSequence1); + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java new file mode 100644 index 000000000..40522533e --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java @@ -0,0 +1,114 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema subRecord10; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord10 = readerSchema.getField("subRecord1").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord10)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord10); + } + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = subRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + subRecord.put(1, charSequence1); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubRecord20(null, (decoder), (customization)); + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + deserializesubRecord20(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord3': "+ unionIndex0)); + } + } + } + + public void deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + populate_subRecord20((decoder)); + } + + private void populate_subRecord20(Decoder decoder) + throws IOException + { + decoder.skipString(); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(1), (decoder), (customization))); + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java new file mode 100644 index 000000000..1a1f99e63 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java @@ -0,0 +1,60 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java new file mode 100644 index 000000000..4e1c73700 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java @@ -0,0 +1,60 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java new file mode 100644 index 000000000..f8ada0c46 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + throw new AvroTypeException("Found \"long\", expecting [\"null\", \"string\"]"); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java new file mode 100644 index 000000000..98351115b --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java new file mode 100644 index 000000000..82064ecbd --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java new file mode 100644 index 000000000..3819b56f8 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java new file mode 100644 index 000000000..db4f82fb4 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java new file mode 100644 index 000000000..e598b2928 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java new file mode 100644 index 000000000..d62297fc9 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java @@ -0,0 +1,71 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_906204958(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_1778260273(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.put(0, null); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_906204958(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.put(0, null); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_2127585735(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + if (unionIndex0 == 1) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java new file mode 100644 index 000000000..ebf71fc34 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + if (unionIndex0 == 1) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java new file mode 100644 index 000000000..17d936e1b --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + if (unionIndex0 == 1) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java new file mode 100644 index 000000000..acdefdd62 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + if (unionIndex0 == 1) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java new file mode 100644 index 000000000..454fe8b7f --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java new file mode 100644 index 000000000..7bbd80759 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java new file mode 100644 index 000000000..f80badf79 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java new file mode 100644 index 000000000..abf3b700d --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java new file mode 100644 index 000000000..ba2c71da8 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + this.testOptionSchema1 = test0 .getTypes().get(2); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java new file mode 100644 index 000000000..dec4be8b0 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + this.testOptionSchema1 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java new file mode 100644 index 000000000..ac530ae30 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(2); + this.testOptionSchema1 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java new file mode 100644 index 000000000..2e518d354 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + this.testOptionSchema1 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java new file mode 100644 index 000000000..5d05a4047 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java @@ -0,0 +1,148 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyInReaderSchemaTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyInReaderSchemaTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence1; + Object oldString1 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + testStringArray1 .clear(); + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java new file mode 100644 index 000000000..2b6ed8f8f --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java @@ -0,0 +1,148 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyInReaderSchemaTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyInReaderSchemaTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence1; + Object oldString1 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + testStringArray1 .clear(); + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java new file mode 100644 index 000000000..6cbf0606e --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java @@ -0,0 +1,148 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = FastStringableTest_javaStringPropertyTest.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyTest0((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyTest1((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyTest; + } + + private void populate_FastStringableTest_javaStringPropertyTest0(IndexedRecord FastStringableTest_javaStringPropertyTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyTest.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence1; + Object oldString1 = FastStringableTest_javaStringPropertyTest.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + testStringArray1 .clear(); + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java new file mode 100644 index 000000000..d1db1358a --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java @@ -0,0 +1,1071 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex7 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex7)); + } + } + List testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema mapMapValueSchema0; + private final Schema mapValueOptionSchema0; + private final Schema field0; + + public Map_of_UNION_GenericDeserializer_2140000109_2140000109(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapValueSchema0 = readerSchema.getValueType(); + this.mapValueOptionSchema0 = mapMapValueSchema0 .getTypes().get(1); + this.field0 = mapValueOptionSchema0 .getField("field").schema(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapValueOptionSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapValueOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + record.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = record.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + record.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex1)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/Map_of_UNION_SpecificDeserializer_971650236_971650236.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/Map_of_UNION_SpecificDeserializer_971650236_971650236.java new file mode 100644 index 000000000..448c4a1d1 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/Map_of_UNION_SpecificDeserializer_971650236_971650236.java @@ -0,0 +1,1081 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_UNION_SpecificDeserializer_971650236_971650236 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Map_of_UNION_SpecificDeserializer_971650236_971650236(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex1)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex2)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex3)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex4)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex5 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex5)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex6 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex6)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex7 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex7)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + List testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex15 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex17)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex21 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex21)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex23 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex23)); + } + } + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex25 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex25 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex25 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex25)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema unionOptionMapValueSchema0; + + public Map_of_record_GenericDeserializer_1223705675_568621313(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOptionMapValueSchema0 = readerSchema.getValueType(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":{\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}}"); + } else { + if (unionIndex0 == 1) { + Map unionOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map unionOptionReuse0 = null; + if ((reuse) instanceof Map) { + unionOptionReuse0 = ((Map)(reuse)); + } + if (unionOptionReuse0 != (null)) { + unionOptionReuse0 .clear(); + unionOption0 = unionOptionReuse0; + } else { + unionOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + unionOption0 = new HashMap(0); + } + } + return unionOption0; + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == unionOptionMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(unionOptionMapValueSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/Map_of_record_GenericDeserializer_1677529043_1677529043.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/Map_of_record_GenericDeserializer_1677529043_1677529043.java new file mode 100644 index 000000000..93ec20996 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/Map_of_record_GenericDeserializer_1677529043_1677529043.java @@ -0,0 +1,95 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_record_GenericDeserializer_1677529043_1677529043 + implements FastDeserializer> +{ + + private final Schema readerSchema; + private final Schema mapMapValueSchema0; + private final Schema field0; + + public Map_of_record_GenericDeserializer_1677529043_1677529043(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapValueSchema0 = readerSchema.getValueType(); + this.field0 = mapMapValueSchema0 .getField("field").schema(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapMapValueSchema0); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + record.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = record.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + record.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java new file mode 100644 index 000000000..dc7862aa2 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java @@ -0,0 +1,61 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserialize(com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRecordWithLargeUnionField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserializeRecordWithLargeUnionField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField RecordWithLargeUnionField; + if ((reuse)!= null) { + RecordWithLargeUnionField = ((com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField)(reuse)); + } else { + RecordWithLargeUnionField = new com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Utf8 charSequence0; + Object oldString0 = RecordWithLargeUnionField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RecordWithLargeUnionField.put(0, charSequence0); + } else { + if (unionIndex0 == 1) { + RecordWithLargeUnionField.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + throw new AvroTypeException(new StringBuilder().append("Found").append(" \"byt").append("es\", ").append("expec").append("ting ").append("[\"str").append("ing\",").append(" \"int").append("\"]").toString()); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + } + return RecordWithLargeUnionField; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java new file mode 100644 index 000000000..b1f22169e --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java @@ -0,0 +1,47 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; + if ((reuse)!= null) { + RemovedTypesTestRecord = ((com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord)(reuse)); + } else { + RemovedTypesTestRecord = new com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord(); + } + Utf8 charSequence0; + Object oldString0 = RemovedTypesTestRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RemovedTypesTestRecord.put(0, charSequence0); + return RemovedTypesTestRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java new file mode 100644 index 000000000..49f5c15e4 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java @@ -0,0 +1,406 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; + if ((reuse)!= null) { + RemovedTypesTestRecord = ((com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord)(reuse)); + } else { + RemovedTypesTestRecord = new com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord(); + } + Utf8 charSequence0; + Object oldString0 = RemovedTypesTestRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RemovedTypesTestRecord.put(0, charSequence0); + populate_RemovedTypesTestRecord0((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord1((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord2((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord3((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord4((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord5((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord6((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord7((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord8((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord9((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord10((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord11((RemovedTypesTestRecord), (customization), (decoder)); + return RemovedTypesTestRecord; + } + + private void populate_RemovedTypesTestRecord0(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.skipBytes(); + long chunkLen0 = (decoder.readArrayStart()); + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 0) { + do { + for (int counter1 = 0; (counter1 0); + } + } + + private void populate_RemovedTypesTestRecord2(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen2 = (decoder.readArrayStart()); + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 0) { + do { + for (int counter3 = 0; (counter3 0); + } + } + + private void populate_RemovedTypesTestRecord3(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.skipFixed(1); + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + } else { + if (unionIndex3 == 1) { + decoder.skipFixed(1); + } else { + throw new RuntimeException(("Illegal union index for 'removedFixedUnion': "+ unionIndex3)); + } + } + } + + private void populate_RemovedTypesTestRecord4(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen4 = (decoder.readArrayStart()); + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 0) { + do { + for (int counter5 = 0; (counter5 0); + } + } + + private void populate_RemovedTypesTestRecord5(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen6 = (decoder.readArrayStart()); + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 0) { + do { + for (int counter7 = 0; (counter7 0); + } + } + + private void populate_RemovedTypesTestRecord6(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.readEnum(); + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + } else { + if (unionIndex6 == 1) { + decoder.readEnum(); + } else { + throw new RuntimeException(("Illegal union index for 'removedEnumUnion': "+ unionIndex6)); + } + } + } + + private void populate_RemovedTypesTestRecord7(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen8 = (decoder.readArrayStart()); + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 0) { + do { + for (int counter9 = 0; (counter9 0); + } + } + + private void populate_RemovedTypesTestRecord8(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen10 = (decoder.readArrayStart()); + while (chunkLen10 > 0) { + for (int counter10 = 0; (counter10 0) { + do { + for (int counter11 = 0; (counter11 0); + } + } + + private void populate_RemovedTypesTestRecord9(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializeRemovedSubRecord0(null, (decoder), (customization)); + int unionIndex9 = (decoder.readIndex()); + if (unionIndex9 == 0) { + decoder.readNull(); + } else { + if (unionIndex9 == 1) { + deserializeRemovedSubRecord0(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'removedSubRecordUnion': "+ unionIndex9)); + } + } + } + + public void deserializeRemovedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + } + + private void populate_RemovedTypesTestRecord10(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen12 = (decoder.readArrayStart()); + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0) { + for (int counter13 = 0; (counter13 0) { + do { + for (int counter14 = 0; (counter14 0); + } + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + do { + for (int counter15 = 0; (counter15 0); + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java new file mode 100644 index 000000000..f5b8cd869 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java @@ -0,0 +1,172 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class SplitRecordTest1_SpecificDeserializer_1718878379_595582209 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public SplitRecordTest1_SpecificDeserializer_1718878379_595582209(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeSplitRecordTest10((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserializeSplitRecordTest10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 SplitRecordTest1; + if ((reuse)!= null) { + SplitRecordTest1 = ((com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1)(reuse)); + } else { + SplitRecordTest1 = new com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1(); + } + SplitRecordTest1 .put(0, deserializeFullRecord0(SplitRecordTest1 .get(0), (decoder), (customization))); + populate_SplitRecordTest10((SplitRecordTest1), (customization), (decoder)); + return SplitRecordTest1; + } + + public com.linkedin.avro.fastserde.generated.avro.FullRecord deserializeFullRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.FullRecord FullRecord; + if ((reuse)!= null) { + FullRecord = ((com.linkedin.avro.fastserde.generated.avro.FullRecord)(reuse)); + } else { + FullRecord = new com.linkedin.avro.fastserde.generated.avro.FullRecord(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FullRecord.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FullRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FullRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex0)); + } + } + FullRecord.put(1, null); + return FullRecord; + } + + private void populate_SplitRecordTest10(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 SplitRecordTest1, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + SplitRecordTest1 .put(1, deserializeFullRecord1(SplitRecordTest1 .get(1), (decoder), (customization))); + List record30 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = SplitRecordTest1 .get(2); + if (oldArray0 instanceof List) { + record30 = ((List) oldArray0); + record30 .clear(); + } else { + record30 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public SplitRecordTest2_SpecificDeserializer_595582209_1718878379(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeSplitRecordTest20((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserializeSplitRecordTest20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 SplitRecordTest2; + if ((reuse)!= null) { + SplitRecordTest2 = ((com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2)(reuse)); + } else { + SplitRecordTest2 = new com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2(); + } + SplitRecordTest2 .put(0, deserializeStringRecord0(SplitRecordTest2 .get(0), (decoder), (customization))); + populate_SplitRecordTest20((SplitRecordTest2), (customization), (decoder)); + return SplitRecordTest2; + } + + public StringRecord deserializeStringRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + StringRecord IntRecord; + if ((reuse)!= null) { + IntRecord = ((StringRecord)(reuse)); + } else { + IntRecord = new StringRecord(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + IntRecord.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = IntRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + IntRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex0)); + } + } + populate_IntRecord0((IntRecord), (customization), (decoder)); + return IntRecord; + } + + private void populate_IntRecord0(StringRecord IntRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + } else { + if (unionIndex1 == 1) { + decoder.readInt(); + } else { + throw new RuntimeException(("Illegal union index for 'field2': "+ unionIndex1)); + } + } + } + + private void populate_SplitRecordTest20(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 SplitRecordTest2, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + SplitRecordTest2 .put(1, deserializeIntRecord0(SplitRecordTest2 .get(1), (decoder), (customization))); + List record30 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = SplitRecordTest2 .get(2); + if (oldArray0 instanceof List) { + record30 = ((List) oldArray0); + record30 .clear(); + } else { + record30 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public StringableRecord_SpecificDeserializer_842267318_842267318(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserialize(com.linkedin.avro.fastserde.generated.avro.StringableRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeStringableRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserializeStringableRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord; + if ((reuse)!= null) { + StringableRecord = ((com.linkedin.avro.fastserde.generated.avro.StringableRecord)(reuse)); + } else { + StringableRecord = new com.linkedin.avro.fastserde.generated.avro.StringableRecord(); + } + Utf8 charSequence0; + Object oldString0 = StringableRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + StringableRecord.put(0, charSequence0); + populate_StringableRecord0((StringableRecord), (customization), (decoder)); + populate_StringableRecord1((StringableRecord), (customization), (decoder)); + populate_StringableRecord2((StringableRecord), (customization), (decoder)); + populate_StringableRecord3((StringableRecord), (customization), (decoder)); + populate_StringableRecord4((StringableRecord), (customization), (decoder)); + return StringableRecord; + } + + private void populate_StringableRecord0(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = StringableRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + StringableRecord.put(1, charSequence1); + Utf8 charSequence2; + Object oldString2 = StringableRecord.get(2); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + StringableRecord.put(2, charSequence2); + } + + private void populate_StringableRecord1(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence3; + Object oldString3 = StringableRecord.get(3); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + StringableRecord.put(3, charSequence3); + Utf8 charSequence4; + Object oldString4 = StringableRecord.get(4); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + StringableRecord.put(4, charSequence4); + } + + private void populate_StringableRecord2(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List urlArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = StringableRecord.get(5); + if (oldArray0 instanceof List) { + urlArray0 = ((List) oldArray0); + urlArray0 .clear(); + } else { + urlArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 urlMap0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), ((int) chunkLen1))); + } else { + Map urlMapReuse0 = null; + Object oldMap0 = StringableRecord.get(6); + if (oldMap0 instanceof Map) { + urlMapReuse0 = ((Map) oldMap0); + } + if (urlMapReuse0 != (null)) { + urlMapReuse0 .clear(); + urlMap0 = urlMapReuse0; + } else { + urlMap0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), 0)); + } else { + urlMap0 = new HashMap(0); + } + } + StringableRecord.put(6, urlMap0); + } + + private void populate_StringableRecord3(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + StringableRecord.put(7, deserializeStringableSubRecord0(StringableRecord.get(7), (decoder), (customization))); + StringableRecord.put(8, deserializeAnotherSubRecord0(StringableRecord.get(8), (decoder), (customization))); + } + + public com.linkedin.avro.fastserde.generated.avro.StringableSubRecord deserializeStringableSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord; + if ((reuse)!= null) { + StringableSubRecord = ((com.linkedin.avro.fastserde.generated.avro.StringableSubRecord)(reuse)); + } else { + StringableSubRecord = new com.linkedin.avro.fastserde.generated.avro.StringableSubRecord(); + } + Utf8 charSequence7; + Object oldString5 = StringableSubRecord.get(0); + if (oldString5 instanceof Utf8) { + charSequence7 = (decoder).readString(((Utf8) oldString5)); + } else { + charSequence7 = (decoder).readString(null); + } + StringableSubRecord.put(0, charSequence7); + populate_StringableSubRecord0((StringableSubRecord), (customization), (decoder)); + return StringableSubRecord; + } + + private void populate_StringableSubRecord0(com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + StringableSubRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence8; + Object oldString6 = StringableSubRecord.get(1); + if (oldString6 instanceof Utf8) { + charSequence8 = (decoder).readString(((Utf8) oldString6)); + } else { + charSequence8 = (decoder).readString(null); + } + StringableSubRecord.put(1, charSequence8); + } else { + if (unionIndex0 == 2) { + StringableSubRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'nullStringIntUnion': "+ unionIndex0)); + } + } + } + } + + public com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord deserializeAnotherSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord AnotherSubRecord; + if ((reuse)!= null) { + AnotherSubRecord = ((com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord)(reuse)); + } else { + AnotherSubRecord = new com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord(); + } + AnotherSubRecord.put(0, deserializeStringableSubRecord0(AnotherSubRecord.get(0), (decoder), (customization))); + return AnotherSubRecord; + } + + private void populate_StringableRecord4(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + StringableRecord.put(9, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence9; + Object oldString7 = StringableRecord.get(9); + if (oldString7 instanceof Utf8) { + charSequence9 = (decoder).readString(((Utf8) oldString7)); + } else { + charSequence9 = (decoder).readString(null); + } + StringableRecord.put(9, charSequence9); + } else { + throw new RuntimeException(("Illegal union index for 'stringUnion': "+ unionIndex1)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java new file mode 100644 index 000000000..85c29a78d --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java @@ -0,0 +1,46 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class TestArrayOfFloats_GenericDeserializer_1408566797_1408566797 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema array_of_float0; + + public TestArrayOfFloats_GenericDeserializer_1408566797_1408566797(Schema readerSchema) { + this.readerSchema = readerSchema; + this.array_of_float0 = readerSchema.getField("array_of_float").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestArrayOfFloats0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestArrayOfFloats0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord TestArrayOfFloats; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + TestArrayOfFloats = ((IndexedRecord)(reuse)); + } else { + TestArrayOfFloats = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + PrimitiveFloatList array_of_float1 = null; + array_of_float1 = ((PrimitiveFloatList) BufferBackedPrimitiveFloatList.readPrimitiveFloatArray(TestArrayOfFloats.get(0), (decoder))); + TestArrayOfFloats.put(0, array_of_float1); + return TestArrayOfFloats; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/TestRecord_GenericDeserializer_473555078_473555078.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/TestRecord_GenericDeserializer_473555078_473555078.java new file mode 100644 index 000000000..9a9ffcffc --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/TestRecord_GenericDeserializer_473555078_473555078.java @@ -0,0 +1,78 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_GenericDeserializer_473555078_473555078 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema map_field0; + + public TestRecord_GenericDeserializer_473555078_473555078(Schema readerSchema) { + this.readerSchema = readerSchema; + this.map_field0 = readerSchema.getField("map_field").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord TestRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + TestRecord = ((IndexedRecord)(reuse)); + } else { + TestRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map map_field1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), ((int) chunkLen0))); + } else { + Map map_fieldReuse0 = null; + Object oldMap0 = TestRecord.get(0); + if (oldMap0 instanceof Map) { + map_fieldReuse0 = ((Map) oldMap0); + } + if (map_fieldReuse0 != (null)) { + map_fieldReuse0 .clear(); + map_field1 = map_fieldReuse0; + } else { + map_field1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), 0)); + } else { + map_field1 = new HashMap(0); + } + } + TestRecord.put(0, map_field1); + return TestRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/TestRecord_SpecificDeserializer_1898726132_553331077.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/TestRecord_SpecificDeserializer_1898726132_553331077.java new file mode 100644 index 000000000..d9c18ac0c --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/TestRecord_SpecificDeserializer_1898726132_553331077.java @@ -0,0 +1,1039 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_1898726132_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Map enumMappingTestEnum0; + private final Map enumMappingTestEnum1; + private final Map enumMappingTestEnum2; + private final Map enumMappingTestEnum3; + + public TestRecord_SpecificDeserializer_1898726132_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + HashMap tempEnumMapping0 = new HashMap(5); + tempEnumMapping0 .put(new Integer(0), new Integer(4)); + tempEnumMapping0 .put(new Integer(1), new Integer(3)); + tempEnumMapping0 .put(new Integer(2), new Integer(1)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + HashMap tempEnumMapping1 = new HashMap(5); + tempEnumMapping1 .put(new Integer(0), new Integer(4)); + tempEnumMapping1 .put(new Integer(1), new Integer(3)); + tempEnumMapping1 .put(new Integer(2), new Integer(1)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + HashMap tempEnumMapping2 = new HashMap(5); + tempEnumMapping2 .put(new Integer(0), new Integer(4)); + tempEnumMapping2 .put(new Integer(1), new Integer(3)); + tempEnumMapping2 .put(new Integer(2), new Integer(1)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + HashMap tempEnumMapping3 = new HashMap(5); + tempEnumMapping3 .put(new Integer(0), new Integer(4)); + tempEnumMapping3 .put(new Integer(1), new Integer(3)); + tempEnumMapping3 .put(new Integer(2), new Integer(1)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + ArrayList defaultArray0 = new ArrayList(); + TestRecord.put(33, defaultArray0); + ArrayList defaultArray1 = new ArrayList(); + TestRecord.put(34, defaultArray1); + ArrayList defaultArray2 = new ArrayList(); + TestRecord.put(35, defaultArray2); + ArrayList defaultArray3 = new ArrayList(); + TestRecord.put(36, defaultArray3); + ArrayList defaultArray4 = new ArrayList(); + TestRecord.put(37, defaultArray4); + ArrayList defaultArray5 = new ArrayList(); + TestRecord.put(38, defaultArray5); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + } else { + if (unionIndex7 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'removedField': "+ unionIndex7)); + } + } + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + } + + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + } + + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex16 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex18)); + } + } + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex22 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex24 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex24)); + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex26 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex26 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex26 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex26)); + } + } + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/TestRecord_SpecificDeserializer_1991094399_553331077.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/TestRecord_SpecificDeserializer_1991094399_553331077.java new file mode 100644 index 000000000..378132bc2 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/TestRecord_SpecificDeserializer_1991094399_553331077.java @@ -0,0 +1,1043 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_1991094399_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Map enumMappingTestEnum0; + private final Map enumMappingTestEnum1; + private final Map enumMappingTestEnum2; + private final Map enumMappingTestEnum3; + + public TestRecord_SpecificDeserializer_1991094399_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + HashMap tempEnumMapping0 = new HashMap(6); + tempEnumMapping0 .put(new Integer(0), new Integer(4)); + tempEnumMapping0 .put(new Integer(1), new Integer(3)); + tempEnumMapping0 .put(new Integer(2), new Integer(1)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(0)); + tempEnumMapping0 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + HashMap tempEnumMapping1 = new HashMap(6); + tempEnumMapping1 .put(new Integer(0), new Integer(4)); + tempEnumMapping1 .put(new Integer(1), new Integer(3)); + tempEnumMapping1 .put(new Integer(2), new Integer(1)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(0)); + tempEnumMapping1 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + HashMap tempEnumMapping2 = new HashMap(6); + tempEnumMapping2 .put(new Integer(0), new Integer(4)); + tempEnumMapping2 .put(new Integer(1), new Integer(3)); + tempEnumMapping2 .put(new Integer(2), new Integer(1)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(0)); + tempEnumMapping2 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + HashMap tempEnumMapping3 = new HashMap(6); + tempEnumMapping3 .put(new Integer(0), new Integer(4)); + tempEnumMapping3 .put(new Integer(1), new Integer(3)); + tempEnumMapping3 .put(new Integer(2), new Integer(1)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(0)); + tempEnumMapping3 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + ArrayList defaultArray0 = new ArrayList(); + TestRecord.put(33, defaultArray0); + ArrayList defaultArray1 = new ArrayList(); + TestRecord.put(34, defaultArray1); + ArrayList defaultArray2 = new ArrayList(); + TestRecord.put(35, defaultArray2); + ArrayList defaultArray3 = new ArrayList(); + TestRecord.put(36, defaultArray3); + ArrayList defaultArray4 = new ArrayList(); + TestRecord.put(37, defaultArray4); + ArrayList defaultArray5 = new ArrayList(); + TestRecord.put(38, defaultArray5); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + } else { + if (unionIndex7 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'removedField': "+ unionIndex7)); + } + } + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + } + + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + } + + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex16 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex18)); + } + } + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex22 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex24 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex24)); + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex26 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex26 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex26 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex26)); + } + } + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/TestRecord_SpecificDeserializer_553331077_553331077.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/TestRecord_SpecificDeserializer_553331077_553331077.java new file mode 100644 index 000000000..bfa744a0a --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/TestRecord_SpecificDeserializer_553331077_553331077.java @@ -0,0 +1,1040 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_553331077_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public TestRecord_SpecificDeserializer_553331077_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex7 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex7)); + } + } + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen16 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 stringArray0 = null; + long chunkLen20 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen20)); + } + while (chunkLen20 > 0) { + for (int counter20 = 0; (counter20 +{ + + private final Schema readerSchema; + private final Schema recordRecordSchema0; + + public UNION_GenericDeserializer_1971822364_1672473580(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordRecordSchema0 = readerSchema.getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordRecordSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(recordRecordSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/UNION_GenericDeserializer_2018567528_1606337179.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/UNION_GenericDeserializer_2018567528_1606337179.java new file mode 100644 index 000000000..bd367f7a9 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/UNION_GenericDeserializer_2018567528_1606337179.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class UNION_GenericDeserializer_2018567528_1606337179 + implements FastDeserializer> +{ + + private final Schema readerSchema; + private final Schema arrayArraySchema0; + private final Schema arrayArrayElemSchema0; + + public UNION_GenericDeserializer_2018567528_1606337179(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArraySchema0 = readerSchema.getTypes().get(1); + this.arrayArrayElemSchema0 = arrayArraySchema0 .getElementType(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), arrayArraySchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + private final Schema mapMapSchema0; + private final Schema mapMapValueSchema0; + + public UNION_GenericDeserializer_568621313_1223705675(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapSchema0 = readerSchema.getTypes().get(1); + this.mapMapValueSchema0 = mapMapSchema0 .getValueType(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapMapValueSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java new file mode 100644 index 000000000..5ec95b1b8 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.MyEnumV1; +import com.linkedin.avro.fastserde.generated.avro.MyEnumV2; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserialize(com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeUnionOfRecordsWithSameNameEnumField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserializeUnionOfRecordsWithSameNameEnumField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField UnionOfRecordsWithSameNameEnumField; + if ((reuse)!= null) { + UnionOfRecordsWithSameNameEnumField = ((com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField)(reuse)); + } else { + UnionOfRecordsWithSameNameEnumField = new com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV10(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV20(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + return UnionOfRecordsWithSameNameEnumField; + } + + public com.linkedin.avro.fastserde.generated.avro.MyRecordV1 deserializeMyRecordV10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.MyRecordV1 MyRecordV1; + if ((reuse)!= null) { + MyRecordV1 = ((com.linkedin.avro.fastserde.generated.avro.MyRecordV1)(reuse)); + } else { + MyRecordV1 = new com.linkedin.avro.fastserde.generated.avro.MyRecordV1(); + } + MyRecordV1 .put(0, Enums.getConstant(MyEnumV1 .class, (decoder.readEnum()))); + return MyRecordV1; + } + + public com.linkedin.avro.fastserde.generated.avro.MyRecordV2 deserializeMyRecordV20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.MyRecordV2 MyRecordV2; + if ((reuse)!= null) { + MyRecordV2 = ((com.linkedin.avro.fastserde.generated.avro.MyRecordV2)(reuse)); + } else { + MyRecordV2 = new com.linkedin.avro.fastserde.generated.avro.MyRecordV2(); + } + MyRecordV2 .put(0, Enums.getConstant(MyEnumV2 .class, (decoder.readEnum()))); + return MyRecordV2; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/recordName_GenericDeserializer_1743054079_1743054079.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/recordName_GenericDeserializer_1743054079_1743054079.java new file mode 100644 index 000000000..a0258db47 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/recordName_GenericDeserializer_1743054079_1743054079.java @@ -0,0 +1,67 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class recordName_GenericDeserializer_1743054079_1743054079 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema unionField0; + + public recordName_GenericDeserializer_1743054079_1743054079(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionField0 = readerSchema.getField("unionField").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecordName0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecordName0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord recordName; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + recordName = ((IndexedRecord)(reuse)); + } else { + recordName = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = recordName.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + recordName.put(0, charSequence0); + populate_recordName0((recordName), (customization), (decoder)); + return recordName; + } + + private void populate_recordName0(IndexedRecord recordName, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + recordName.put(1, null); + } else { + if (unionIndex0 == 1) { + recordName.put(1, deserializerecordName0(recordName.get(1), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1025741720_1557256887.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1025741720_1557256887.java new file mode 100644 index 000000000..8bb0d7b29 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1025741720_1557256887.java @@ -0,0 +1,96 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1025741720_1557256887 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_1025741720_1557256887(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + Map someIntsOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } + } + record.put(0, someIntsOption0); + } else { + throw new RuntimeException(("Illegal union index for 'someInts': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1126840752_2099305627.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1126840752_2099305627.java new file mode 100644 index 000000000..6d70acf77 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1126840752_2099305627.java @@ -0,0 +1,50 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1126840752_2099305627 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1126840752_2099305627(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + record.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 1) { + throw new AvroTypeException("Found \"string\", expecting \"int\""); + } else { + throw new RuntimeException(("Illegal union index for 'someField': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1191367445_653449771.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1191367445_653449771.java new file mode 100644 index 000000000..fc41b2d78 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1191367445_653449771.java @@ -0,0 +1,69 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1191367445_653449771 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_1191367445_653449771(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList someIntsOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someIntsOption0 = ((PrimitiveIntList) oldArray0); + someIntsOption0 .clear(); + } else { + someIntsOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1373882843_1971822364(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + record.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'someInt': "+ unionIndex0)); + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1556659421_711533897.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1556659421_711533897.java new file mode 100644 index 000000000..dcee8e0ec --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1556659421_711533897.java @@ -0,0 +1,72 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1556659421_711533897 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema subRecord0; + + public record_GenericDeserializer_1556659421_711533897(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"subRecord\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"subRecord\",\"fields\":[{\"name\":\"someInt1\",\"type\":\"int\",\"doc\":\"\"},{\"name\":\"someInt2\",\"type\":\"int\",\"doc\":\"\"}]}"); + } else { + if (unionIndex0 == 1) { + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex0)); + } + } + return record; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord0); + } + subRecord.put(0, (decoder.readInt())); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + subRecord.put(1, (decoder.readInt())); + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1557256887_1025741720.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1557256887_1025741720.java new file mode 100644 index 000000000..ffbef6a42 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1557256887_1025741720.java @@ -0,0 +1,81 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1557256887_1025741720 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsMapSchema0; + private final Schema someIntsMapValueSchema0; + + public record_GenericDeserializer_1557256887_1025741720(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsMapSchema0 = someInts0 .getTypes().get(1); + this.someIntsMapValueSchema0 = someIntsMapSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map someInts1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } + } + record.put(0, someInts1); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1557256887_753570467.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1557256887_753570467.java new file mode 100644 index 000000000..4f4c7b19c --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1557256887_753570467.java @@ -0,0 +1,79 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1557256887_753570467 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsMapSchema0; + + public record_GenericDeserializer_1557256887_753570467(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsMapSchema0 = someInts0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map someInts1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } + } + record.put(0, someInts1); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1672473580_1971822364.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1672473580_1971822364.java new file mode 100644 index 000000000..c7837d439 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1672473580_1971822364.java @@ -0,0 +1,50 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1672473580_1971822364 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1672473580_1971822364(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}"); + } else { + if (unionIndex0 == 1) { + return deserializerecord0((reuse), (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1971822364_1373882843.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1971822364_1373882843.java new file mode 100644 index 000000000..59945519f --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_1971822364_1373882843.java @@ -0,0 +1,42 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1971822364_1373882843 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInt0; + + public record_GenericDeserializer_1971822364_1373882843(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInt0 = readerSchema.getField("someInt").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_653449771_1191367445.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_653449771_1191367445.java new file mode 100644 index 000000000..fb662a7dd --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_653449771_1191367445.java @@ -0,0 +1,61 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_653449771_1191367445 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsArraySchema0; + + public record_GenericDeserializer_653449771_1191367445(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsArraySchema0 = someInts0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + PrimitiveIntList someInts1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someInts1 = ((PrimitiveIntList) oldArray0); + someInts1 .clear(); + } else { + someInts1 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsArraySchema0; + private final Schema someIntsArrayElemSchema0; + + public record_GenericDeserializer_653449771_813379571(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsArraySchema0 = someInts0 .getTypes().get(1); + this.someIntsArrayElemSchema0 = someIntsArraySchema0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List someInts1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof List) { + someInts1 = ((List) oldArray0); + someInts1 .clear(); + } else { + someInts1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), someIntsArraySchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema subRecord0; + private final Schema subRecordRecordSchema0; + + public record_GenericDeserializer_711533897_1556659421(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + this.subRecordRecordSchema0 = subRecord0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); + return record; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecordRecordSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecordRecordSchema0); + } + subRecord.put(0, (decoder.readInt())); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + subRecord.put(1, (decoder.readInt())); + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_753570467_1557256887.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_753570467_1557256887.java new file mode 100644 index 000000000..f3714a26b --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_753570467_1557256887.java @@ -0,0 +1,87 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_753570467_1557256887 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_753570467_1557256887(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + Map someIntsOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } + } + record.put(0, someIntsOption0); + } else { + throw new RuntimeException(("Illegal union index for 'someInts': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_813379571_653449771.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_813379571_653449771.java new file mode 100644 index 000000000..1e8a4ffe1 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_5/record_GenericDeserializer_813379571_653449771.java @@ -0,0 +1,83 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_813379571_653449771 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_813379571_653449771(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList someIntsOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someIntsOption0 = ((PrimitiveIntList) oldArray0); + someIntsOption0 .clear(); + } else { + someIntsOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + + public testRecord_GenericDeserializer_1146484089_1256982207(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(3); + tempEnumMapping0 .put(new Integer(0), new Integer(0)); + tempEnumMapping0 .put(new Integer(1), new Integer(1)); + tempEnumMapping0 .put(new Integer(2), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.testEnum: No match for C")); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializetestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializetestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord testRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + testRecord = ((IndexedRecord)(reuse)); + } else { + testRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + testRecord.put(0, enumValue0); + return testRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/Array_of_BOOLEAN_GenericSerializer_869749973.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/Array_of_BOOLEAN_GenericSerializer_869749973.java new file mode 100644 index 000000000..c29784185 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/Array_of_BOOLEAN_GenericSerializer_869749973.java @@ -0,0 +1,41 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.io.Encoder; + +public class Array_of_BOOLEAN_GenericSerializer_869749973 + implements FastSerializer> +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveBooleanList) { + PrimitiveBooleanList primitiveList0 = ((PrimitiveBooleanList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveDoubleList) { + PrimitiveDoubleList primitiveList0 = ((PrimitiveDoubleList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveFloatList) { + PrimitiveFloatList primitiveList0 = ((PrimitiveFloatList) array0); + if (primitiveList0 instanceof BufferBackedPrimitiveFloatList) { + BufferBackedPrimitiveFloatList bufferBackedPrimitiveFloatList = ((BufferBackedPrimitiveFloatList) primitiveList0); + bufferBackedPrimitiveFloatList.writeFloats((encoder)); + } else { + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList0 = ((PrimitiveIntList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveLongList) { + PrimitiveLongList primitiveList0 = ((PrimitiveLongList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (int counter0 = 0; (counter0 ) data).get(counter0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/Array_of_record_GenericSerializer_477614132.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/Array_of_record_GenericSerializer_477614132.java new file mode 100644 index 000000000..147e5bb59 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/Array_of_record_GenericSerializer_477614132.java @@ -0,0 +1,53 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Array_of_record_GenericSerializer_477614132 + implements FastSerializer> +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (int counter0 = 0; (counter0 ) data).get(counter0); + serializeRecord0(record0, (encoder), (customization)); + } + } + (encoder).writeArrayEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java new file mode 100644 index 000000000..06cfb40a8 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java @@ -0,0 +1,4527 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(1))); + (encoder).writeInt(((Integer) data.get(2))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(3))); + (encoder).writeInt(((Integer) data.get(4))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(5))); + (encoder).writeInt(((Integer) data.get(6))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(7))); + (encoder).writeInt(((Integer) data.get(8))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(9))); + (encoder).writeInt(((Integer) data.get(10))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(11))); + (encoder).writeInt(((Integer) data.get(12))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(13))); + (encoder).writeInt(((Integer) data.get(14))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(15))); + (encoder).writeInt(((Integer) data.get(16))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(17))); + (encoder).writeInt(((Integer) data.get(18))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(19))); + (encoder).writeInt(((Integer) data.get(20))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(21))); + (encoder).writeInt(((Integer) data.get(22))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(23))); + (encoder).writeInt(((Integer) data.get(24))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(25))); + (encoder).writeInt(((Integer) data.get(26))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(27))); + (encoder).writeInt(((Integer) data.get(28))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(29))); + (encoder).writeInt(((Integer) data.get(30))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(31))); + (encoder).writeInt(((Integer) data.get(32))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(33))); + (encoder).writeInt(((Integer) data.get(34))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(35))); + (encoder).writeInt(((Integer) data.get(36))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(37))); + (encoder).writeInt(((Integer) data.get(38))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(39))); + (encoder).writeInt(((Integer) data.get(40))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(41))); + (encoder).writeInt(((Integer) data.get(42))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(43))); + (encoder).writeInt(((Integer) data.get(44))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(45))); + (encoder).writeInt(((Integer) data.get(46))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(47))); + (encoder).writeInt(((Integer) data.get(48))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(49))); + (encoder).writeInt(((Integer) data.get(50))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(51))); + (encoder).writeInt(((Integer) data.get(52))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(53))); + (encoder).writeInt(((Integer) data.get(54))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(55))); + (encoder).writeInt(((Integer) data.get(56))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(57))); + (encoder).writeInt(((Integer) data.get(58))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(59))); + (encoder).writeInt(((Integer) data.get(60))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(61))); + (encoder).writeInt(((Integer) data.get(62))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(63))); + (encoder).writeInt(((Integer) data.get(64))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(65))); + (encoder).writeInt(((Integer) data.get(66))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(67))); + (encoder).writeInt(((Integer) data.get(68))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(69))); + (encoder).writeInt(((Integer) data.get(70))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(71))); + (encoder).writeInt(((Integer) data.get(72))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(73))); + (encoder).writeInt(((Integer) data.get(74))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(75))); + (encoder).writeInt(((Integer) data.get(76))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(77))); + (encoder).writeInt(((Integer) data.get(78))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(79))); + (encoder).writeInt(((Integer) data.get(80))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(81))); + (encoder).writeInt(((Integer) data.get(82))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(83))); + (encoder).writeInt(((Integer) data.get(84))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(85))); + (encoder).writeInt(((Integer) data.get(86))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(87))); + (encoder).writeInt(((Integer) data.get(88))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(89))); + (encoder).writeInt(((Integer) data.get(90))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(91))); + (encoder).writeInt(((Integer) data.get(92))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(93))); + (encoder).writeInt(((Integer) data.get(94))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(95))); + (encoder).writeInt(((Integer) data.get(96))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(97))); + (encoder).writeInt(((Integer) data.get(98))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(99))); + (encoder).writeInt(((Integer) data.get(100))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(101))); + (encoder).writeInt(((Integer) data.get(102))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(103))); + (encoder).writeInt(((Integer) data.get(104))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(105))); + (encoder).writeInt(((Integer) data.get(106))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(107))); + (encoder).writeInt(((Integer) data.get(108))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(109))); + (encoder).writeInt(((Integer) data.get(110))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(111))); + (encoder).writeInt(((Integer) data.get(112))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(113))); + (encoder).writeInt(((Integer) data.get(114))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(115))); + (encoder).writeInt(((Integer) data.get(116))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(117))); + (encoder).writeInt(((Integer) data.get(118))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(119))); + (encoder).writeInt(((Integer) data.get(120))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(121))); + (encoder).writeInt(((Integer) data.get(122))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(123))); + (encoder).writeInt(((Integer) data.get(124))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(125))); + (encoder).writeInt(((Integer) data.get(126))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(127))); + (encoder).writeInt(((Integer) data.get(128))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(129))); + (encoder).writeInt(((Integer) data.get(130))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(131))); + (encoder).writeInt(((Integer) data.get(132))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(133))); + (encoder).writeInt(((Integer) data.get(134))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(135))); + (encoder).writeInt(((Integer) data.get(136))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(137))); + (encoder).writeInt(((Integer) data.get(138))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(139))); + (encoder).writeInt(((Integer) data.get(140))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(141))); + (encoder).writeInt(((Integer) data.get(142))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(143))); + (encoder).writeInt(((Integer) data.get(144))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(145))); + (encoder).writeInt(((Integer) data.get(146))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(147))); + (encoder).writeInt(((Integer) data.get(148))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(149))); + (encoder).writeInt(((Integer) data.get(150))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(151))); + (encoder).writeInt(((Integer) data.get(152))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(153))); + (encoder).writeInt(((Integer) data.get(154))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(155))); + (encoder).writeInt(((Integer) data.get(156))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(157))); + (encoder).writeInt(((Integer) data.get(158))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(159))); + (encoder).writeInt(((Integer) data.get(160))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(161))); + (encoder).writeInt(((Integer) data.get(162))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(163))); + (encoder).writeInt(((Integer) data.get(164))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(165))); + (encoder).writeInt(((Integer) data.get(166))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(167))); + (encoder).writeInt(((Integer) data.get(168))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(169))); + (encoder).writeInt(((Integer) data.get(170))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(171))); + (encoder).writeInt(((Integer) data.get(172))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(173))); + (encoder).writeInt(((Integer) data.get(174))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(175))); + (encoder).writeInt(((Integer) data.get(176))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(177))); + (encoder).writeInt(((Integer) data.get(178))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(179))); + (encoder).writeInt(((Integer) data.get(180))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(181))); + (encoder).writeInt(((Integer) data.get(182))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(183))); + (encoder).writeInt(((Integer) data.get(184))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(185))); + (encoder).writeInt(((Integer) data.get(186))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(187))); + (encoder).writeInt(((Integer) data.get(188))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(189))); + (encoder).writeInt(((Integer) data.get(190))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(191))); + (encoder).writeInt(((Integer) data.get(192))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(193))); + (encoder).writeInt(((Integer) data.get(194))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(195))); + (encoder).writeInt(((Integer) data.get(196))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(197))); + (encoder).writeInt(((Integer) data.get(198))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(199))); + (encoder).writeInt(((Integer) data.get(200))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(201))); + (encoder).writeInt(((Integer) data.get(202))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(203))); + (encoder).writeInt(((Integer) data.get(204))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(205))); + (encoder).writeInt(((Integer) data.get(206))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(207))); + (encoder).writeInt(((Integer) data.get(208))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(209))); + (encoder).writeInt(((Integer) data.get(210))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(211))); + (encoder).writeInt(((Integer) data.get(212))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(213))); + (encoder).writeInt(((Integer) data.get(214))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(215))); + (encoder).writeInt(((Integer) data.get(216))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(217))); + (encoder).writeInt(((Integer) data.get(218))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(219))); + (encoder).writeInt(((Integer) data.get(220))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(221))); + (encoder).writeInt(((Integer) data.get(222))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(223))); + (encoder).writeInt(((Integer) data.get(224))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(225))); + (encoder).writeInt(((Integer) data.get(226))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(227))); + (encoder).writeInt(((Integer) data.get(228))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(229))); + (encoder).writeInt(((Integer) data.get(230))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(231))); + (encoder).writeInt(((Integer) data.get(232))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(233))); + (encoder).writeInt(((Integer) data.get(234))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(235))); + (encoder).writeInt(((Integer) data.get(236))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(237))); + (encoder).writeInt(((Integer) data.get(238))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(239))); + (encoder).writeInt(((Integer) data.get(240))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(241))); + (encoder).writeInt(((Integer) data.get(242))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(243))); + (encoder).writeInt(((Integer) data.get(244))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(245))); + (encoder).writeInt(((Integer) data.get(246))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(247))); + (encoder).writeInt(((Integer) data.get(248))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(249))); + (encoder).writeInt(((Integer) data.get(250))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(251))); + (encoder).writeInt(((Integer) data.get(252))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(253))); + (encoder).writeInt(((Integer) data.get(254))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(255))); + (encoder).writeInt(((Integer) data.get(256))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(257))); + (encoder).writeInt(((Integer) data.get(258))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(259))); + (encoder).writeInt(((Integer) data.get(260))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(261))); + (encoder).writeInt(((Integer) data.get(262))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(263))); + (encoder).writeInt(((Integer) data.get(264))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(265))); + (encoder).writeInt(((Integer) data.get(266))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(267))); + (encoder).writeInt(((Integer) data.get(268))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(269))); + (encoder).writeInt(((Integer) data.get(270))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(271))); + (encoder).writeInt(((Integer) data.get(272))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(273))); + (encoder).writeInt(((Integer) data.get(274))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(275))); + (encoder).writeInt(((Integer) data.get(276))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(277))); + (encoder).writeInt(((Integer) data.get(278))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(279))); + (encoder).writeInt(((Integer) data.get(280))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(281))); + (encoder).writeInt(((Integer) data.get(282))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(283))); + (encoder).writeInt(((Integer) data.get(284))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(285))); + (encoder).writeInt(((Integer) data.get(286))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(287))); + (encoder).writeInt(((Integer) data.get(288))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(289))); + (encoder).writeInt(((Integer) data.get(290))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(291))); + (encoder).writeInt(((Integer) data.get(292))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(293))); + (encoder).writeInt(((Integer) data.get(294))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(295))); + (encoder).writeInt(((Integer) data.get(296))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(297))); + (encoder).writeInt(((Integer) data.get(298))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(299))); + (encoder).writeInt(((Integer) data.get(300))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(301))); + (encoder).writeInt(((Integer) data.get(302))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(303))); + (encoder).writeInt(((Integer) data.get(304))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(305))); + (encoder).writeInt(((Integer) data.get(306))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(307))); + (encoder).writeInt(((Integer) data.get(308))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(309))); + (encoder).writeInt(((Integer) data.get(310))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(311))); + (encoder).writeInt(((Integer) data.get(312))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(313))); + (encoder).writeInt(((Integer) data.get(314))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(315))); + (encoder).writeInt(((Integer) data.get(316))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(317))); + (encoder).writeInt(((Integer) data.get(318))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(319))); + (encoder).writeInt(((Integer) data.get(320))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(321))); + (encoder).writeInt(((Integer) data.get(322))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(323))); + (encoder).writeInt(((Integer) data.get(324))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(325))); + (encoder).writeInt(((Integer) data.get(326))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(327))); + (encoder).writeInt(((Integer) data.get(328))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(329))); + (encoder).writeInt(((Integer) data.get(330))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(331))); + (encoder).writeInt(((Integer) data.get(332))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(333))); + (encoder).writeInt(((Integer) data.get(334))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(335))); + (encoder).writeInt(((Integer) data.get(336))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(337))); + (encoder).writeInt(((Integer) data.get(338))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(339))); + (encoder).writeInt(((Integer) data.get(340))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(341))); + (encoder).writeInt(((Integer) data.get(342))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(343))); + (encoder).writeInt(((Integer) data.get(344))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(345))); + (encoder).writeInt(((Integer) data.get(346))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(347))); + (encoder).writeInt(((Integer) data.get(348))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(349))); + (encoder).writeInt(((Integer) data.get(350))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(351))); + (encoder).writeInt(((Integer) data.get(352))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(353))); + (encoder).writeInt(((Integer) data.get(354))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(355))); + (encoder).writeInt(((Integer) data.get(356))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(357))); + (encoder).writeInt(((Integer) data.get(358))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(359))); + (encoder).writeInt(((Integer) data.get(360))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(361))); + (encoder).writeInt(((Integer) data.get(362))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(363))); + (encoder).writeInt(((Integer) data.get(364))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(365))); + (encoder).writeInt(((Integer) data.get(366))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(367))); + (encoder).writeInt(((Integer) data.get(368))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(369))); + (encoder).writeInt(((Integer) data.get(370))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(371))); + (encoder).writeInt(((Integer) data.get(372))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(373))); + (encoder).writeInt(((Integer) data.get(374))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(375))); + (encoder).writeInt(((Integer) data.get(376))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(377))); + (encoder).writeInt(((Integer) data.get(378))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(379))); + (encoder).writeInt(((Integer) data.get(380))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(381))); + (encoder).writeInt(((Integer) data.get(382))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(383))); + (encoder).writeInt(((Integer) data.get(384))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(385))); + (encoder).writeInt(((Integer) data.get(386))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(387))); + (encoder).writeInt(((Integer) data.get(388))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(389))); + (encoder).writeInt(((Integer) data.get(390))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(391))); + (encoder).writeInt(((Integer) data.get(392))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(393))); + (encoder).writeInt(((Integer) data.get(394))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(395))); + (encoder).writeInt(((Integer) data.get(396))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(397))); + (encoder).writeInt(((Integer) data.get(398))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(399))); + (encoder).writeInt(((Integer) data.get(400))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(401))); + (encoder).writeInt(((Integer) data.get(402))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(403))); + (encoder).writeInt(((Integer) data.get(404))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(405))); + (encoder).writeInt(((Integer) data.get(406))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(407))); + (encoder).writeInt(((Integer) data.get(408))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(409))); + (encoder).writeInt(((Integer) data.get(410))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(411))); + (encoder).writeInt(((Integer) data.get(412))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(413))); + (encoder).writeInt(((Integer) data.get(414))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(415))); + (encoder).writeInt(((Integer) data.get(416))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(417))); + (encoder).writeInt(((Integer) data.get(418))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(419))); + (encoder).writeInt(((Integer) data.get(420))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(421))); + (encoder).writeInt(((Integer) data.get(422))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(423))); + (encoder).writeInt(((Integer) data.get(424))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(425))); + (encoder).writeInt(((Integer) data.get(426))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(427))); + (encoder).writeInt(((Integer) data.get(428))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(429))); + (encoder).writeInt(((Integer) data.get(430))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(431))); + (encoder).writeInt(((Integer) data.get(432))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(433))); + (encoder).writeInt(((Integer) data.get(434))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(435))); + (encoder).writeInt(((Integer) data.get(436))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(437))); + (encoder).writeInt(((Integer) data.get(438))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(439))); + (encoder).writeInt(((Integer) data.get(440))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(441))); + (encoder).writeInt(((Integer) data.get(442))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(443))); + (encoder).writeInt(((Integer) data.get(444))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(445))); + (encoder).writeInt(((Integer) data.get(446))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(447))); + (encoder).writeInt(((Integer) data.get(448))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(449))); + (encoder).writeInt(((Integer) data.get(450))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(451))); + (encoder).writeInt(((Integer) data.get(452))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(453))); + (encoder).writeInt(((Integer) data.get(454))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(455))); + (encoder).writeInt(((Integer) data.get(456))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(457))); + (encoder).writeInt(((Integer) data.get(458))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(459))); + (encoder).writeInt(((Integer) data.get(460))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(461))); + (encoder).writeInt(((Integer) data.get(462))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(463))); + (encoder).writeInt(((Integer) data.get(464))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(465))); + (encoder).writeInt(((Integer) data.get(466))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(467))); + (encoder).writeInt(((Integer) data.get(468))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(469))); + (encoder).writeInt(((Integer) data.get(470))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(471))); + (encoder).writeInt(((Integer) data.get(472))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(473))); + (encoder).writeInt(((Integer) data.get(474))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(475))); + (encoder).writeInt(((Integer) data.get(476))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(477))); + (encoder).writeInt(((Integer) data.get(478))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(479))); + (encoder).writeInt(((Integer) data.get(480))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(481))); + (encoder).writeInt(((Integer) data.get(482))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(483))); + (encoder).writeInt(((Integer) data.get(484))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(485))); + (encoder).writeInt(((Integer) data.get(486))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(487))); + (encoder).writeInt(((Integer) data.get(488))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(489))); + (encoder).writeInt(((Integer) data.get(490))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(491))); + (encoder).writeInt(((Integer) data.get(492))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(493))); + (encoder).writeInt(((Integer) data.get(494))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(495))); + (encoder).writeInt(((Integer) data.get(496))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(497))); + (encoder).writeInt(((Integer) data.get(498))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(499))); + (encoder).writeInt(((Integer) data.get(500))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(501))); + (encoder).writeInt(((Integer) data.get(502))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(503))); + (encoder).writeInt(((Integer) data.get(504))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(505))); + (encoder).writeInt(((Integer) data.get(506))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(507))); + (encoder).writeInt(((Integer) data.get(508))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(509))); + (encoder).writeInt(((Integer) data.get(510))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(511))); + (encoder).writeInt(((Integer) data.get(512))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(513))); + (encoder).writeInt(((Integer) data.get(514))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(515))); + (encoder).writeInt(((Integer) data.get(516))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(517))); + (encoder).writeInt(((Integer) data.get(518))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(519))); + (encoder).writeInt(((Integer) data.get(520))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(521))); + (encoder).writeInt(((Integer) data.get(522))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(523))); + (encoder).writeInt(((Integer) data.get(524))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(525))); + (encoder).writeInt(((Integer) data.get(526))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(527))); + (encoder).writeInt(((Integer) data.get(528))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(529))); + (encoder).writeInt(((Integer) data.get(530))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(531))); + (encoder).writeInt(((Integer) data.get(532))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(533))); + (encoder).writeInt(((Integer) data.get(534))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(535))); + (encoder).writeInt(((Integer) data.get(536))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(537))); + (encoder).writeInt(((Integer) data.get(538))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(539))); + (encoder).writeInt(((Integer) data.get(540))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(541))); + (encoder).writeInt(((Integer) data.get(542))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(543))); + (encoder).writeInt(((Integer) data.get(544))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(545))); + (encoder).writeInt(((Integer) data.get(546))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(547))); + (encoder).writeInt(((Integer) data.get(548))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(549))); + (encoder).writeInt(((Integer) data.get(550))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(551))); + (encoder).writeInt(((Integer) data.get(552))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(553))); + (encoder).writeInt(((Integer) data.get(554))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(555))); + (encoder).writeInt(((Integer) data.get(556))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(557))); + (encoder).writeInt(((Integer) data.get(558))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(559))); + (encoder).writeInt(((Integer) data.get(560))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(561))); + (encoder).writeInt(((Integer) data.get(562))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(563))); + (encoder).writeInt(((Integer) data.get(564))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(565))); + (encoder).writeInt(((Integer) data.get(566))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(567))); + (encoder).writeInt(((Integer) data.get(568))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(569))); + (encoder).writeInt(((Integer) data.get(570))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(571))); + (encoder).writeInt(((Integer) data.get(572))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(573))); + (encoder).writeInt(((Integer) data.get(574))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(575))); + (encoder).writeInt(((Integer) data.get(576))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(577))); + (encoder).writeInt(((Integer) data.get(578))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(579))); + (encoder).writeInt(((Integer) data.get(580))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(581))); + (encoder).writeInt(((Integer) data.get(582))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(583))); + (encoder).writeInt(((Integer) data.get(584))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(585))); + (encoder).writeInt(((Integer) data.get(586))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(587))); + (encoder).writeInt(((Integer) data.get(588))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(589))); + (encoder).writeInt(((Integer) data.get(590))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(591))); + (encoder).writeInt(((Integer) data.get(592))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(593))); + (encoder).writeInt(((Integer) data.get(594))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(595))); + (encoder).writeInt(((Integer) data.get(596))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(597))); + (encoder).writeInt(((Integer) data.get(598))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(599))); + (encoder).writeInt(((Integer) data.get(600))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(601))); + (encoder).writeInt(((Integer) data.get(602))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(603))); + (encoder).writeInt(((Integer) data.get(604))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(605))); + (encoder).writeInt(((Integer) data.get(606))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(607))); + (encoder).writeInt(((Integer) data.get(608))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(609))); + (encoder).writeInt(((Integer) data.get(610))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(611))); + (encoder).writeInt(((Integer) data.get(612))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(613))); + (encoder).writeInt(((Integer) data.get(614))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(615))); + (encoder).writeInt(((Integer) data.get(616))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(617))); + (encoder).writeInt(((Integer) data.get(618))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(619))); + (encoder).writeInt(((Integer) data.get(620))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(621))); + (encoder).writeInt(((Integer) data.get(622))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(623))); + (encoder).writeInt(((Integer) data.get(624))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(625))); + (encoder).writeInt(((Integer) data.get(626))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(627))); + (encoder).writeInt(((Integer) data.get(628))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(629))); + (encoder).writeInt(((Integer) data.get(630))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(631))); + (encoder).writeInt(((Integer) data.get(632))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(633))); + (encoder).writeInt(((Integer) data.get(634))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(635))); + (encoder).writeInt(((Integer) data.get(636))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(637))); + (encoder).writeInt(((Integer) data.get(638))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(639))); + (encoder).writeInt(((Integer) data.get(640))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(641))); + (encoder).writeInt(((Integer) data.get(642))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(643))); + (encoder).writeInt(((Integer) data.get(644))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(645))); + (encoder).writeInt(((Integer) data.get(646))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(647))); + (encoder).writeInt(((Integer) data.get(648))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(649))); + (encoder).writeInt(((Integer) data.get(650))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(651))); + (encoder).writeInt(((Integer) data.get(652))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(653))); + (encoder).writeInt(((Integer) data.get(654))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(655))); + (encoder).writeInt(((Integer) data.get(656))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(657))); + (encoder).writeInt(((Integer) data.get(658))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(659))); + (encoder).writeInt(((Integer) data.get(660))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(661))); + (encoder).writeInt(((Integer) data.get(662))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(663))); + (encoder).writeInt(((Integer) data.get(664))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(665))); + (encoder).writeInt(((Integer) data.get(666))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(667))); + (encoder).writeInt(((Integer) data.get(668))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(669))); + (encoder).writeInt(((Integer) data.get(670))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(671))); + (encoder).writeInt(((Integer) data.get(672))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(673))); + (encoder).writeInt(((Integer) data.get(674))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(675))); + (encoder).writeInt(((Integer) data.get(676))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(677))); + (encoder).writeInt(((Integer) data.get(678))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(679))); + (encoder).writeInt(((Integer) data.get(680))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(681))); + (encoder).writeInt(((Integer) data.get(682))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(683))); + (encoder).writeInt(((Integer) data.get(684))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(685))); + (encoder).writeInt(((Integer) data.get(686))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(687))); + (encoder).writeInt(((Integer) data.get(688))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(689))); + (encoder).writeInt(((Integer) data.get(690))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(691))); + (encoder).writeInt(((Integer) data.get(692))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(693))); + (encoder).writeInt(((Integer) data.get(694))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(695))); + (encoder).writeInt(((Integer) data.get(696))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(697))); + (encoder).writeInt(((Integer) data.get(698))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(699))); + (encoder).writeInt(((Integer) data.get(700))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(701))); + (encoder).writeInt(((Integer) data.get(702))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(703))); + (encoder).writeInt(((Integer) data.get(704))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(705))); + (encoder).writeInt(((Integer) data.get(706))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(707))); + (encoder).writeInt(((Integer) data.get(708))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(709))); + (encoder).writeInt(((Integer) data.get(710))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(711))); + (encoder).writeInt(((Integer) data.get(712))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(713))); + (encoder).writeInt(((Integer) data.get(714))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(715))); + (encoder).writeInt(((Integer) data.get(716))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(717))); + (encoder).writeInt(((Integer) data.get(718))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(719))); + (encoder).writeInt(((Integer) data.get(720))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(721))); + (encoder).writeInt(((Integer) data.get(722))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(723))); + (encoder).writeInt(((Integer) data.get(724))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(725))); + (encoder).writeInt(((Integer) data.get(726))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(727))); + (encoder).writeInt(((Integer) data.get(728))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(729))); + (encoder).writeInt(((Integer) data.get(730))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(731))); + (encoder).writeInt(((Integer) data.get(732))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(733))); + (encoder).writeInt(((Integer) data.get(734))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(735))); + (encoder).writeInt(((Integer) data.get(736))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(737))); + (encoder).writeInt(((Integer) data.get(738))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(739))); + (encoder).writeInt(((Integer) data.get(740))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(741))); + (encoder).writeInt(((Integer) data.get(742))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(743))); + (encoder).writeInt(((Integer) data.get(744))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(745))); + (encoder).writeInt(((Integer) data.get(746))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(747))); + (encoder).writeInt(((Integer) data.get(748))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(749))); + (encoder).writeInt(((Integer) data.get(750))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(751))); + (encoder).writeInt(((Integer) data.get(752))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(753))); + (encoder).writeInt(((Integer) data.get(754))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(755))); + (encoder).writeInt(((Integer) data.get(756))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(757))); + (encoder).writeInt(((Integer) data.get(758))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(759))); + (encoder).writeInt(((Integer) data.get(760))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(761))); + (encoder).writeInt(((Integer) data.get(762))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(763))); + (encoder).writeInt(((Integer) data.get(764))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(765))); + (encoder).writeInt(((Integer) data.get(766))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(767))); + (encoder).writeInt(((Integer) data.get(768))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(769))); + (encoder).writeInt(((Integer) data.get(770))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(771))); + (encoder).writeInt(((Integer) data.get(772))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(773))); + (encoder).writeInt(((Integer) data.get(774))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(775))); + (encoder).writeInt(((Integer) data.get(776))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(777))); + (encoder).writeInt(((Integer) data.get(778))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(779))); + (encoder).writeInt(((Integer) data.get(780))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(781))); + (encoder).writeInt(((Integer) data.get(782))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(783))); + (encoder).writeInt(((Integer) data.get(784))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(785))); + (encoder).writeInt(((Integer) data.get(786))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(787))); + (encoder).writeInt(((Integer) data.get(788))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(789))); + (encoder).writeInt(((Integer) data.get(790))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(791))); + (encoder).writeInt(((Integer) data.get(792))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(793))); + (encoder).writeInt(((Integer) data.get(794))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(795))); + (encoder).writeInt(((Integer) data.get(796))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(797))); + (encoder).writeInt(((Integer) data.get(798))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(799))); + (encoder).writeInt(((Integer) data.get(800))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(801))); + (encoder).writeInt(((Integer) data.get(802))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(803))); + (encoder).writeInt(((Integer) data.get(804))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(805))); + (encoder).writeInt(((Integer) data.get(806))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(807))); + (encoder).writeInt(((Integer) data.get(808))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(809))); + (encoder).writeInt(((Integer) data.get(810))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(811))); + (encoder).writeInt(((Integer) data.get(812))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(813))); + (encoder).writeInt(((Integer) data.get(814))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(815))); + (encoder).writeInt(((Integer) data.get(816))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(817))); + (encoder).writeInt(((Integer) data.get(818))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(819))); + (encoder).writeInt(((Integer) data.get(820))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(821))); + (encoder).writeInt(((Integer) data.get(822))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(823))); + (encoder).writeInt(((Integer) data.get(824))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(825))); + (encoder).writeInt(((Integer) data.get(826))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(827))); + (encoder).writeInt(((Integer) data.get(828))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(829))); + (encoder).writeInt(((Integer) data.get(830))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(831))); + (encoder).writeInt(((Integer) data.get(832))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(833))); + (encoder).writeInt(((Integer) data.get(834))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(835))); + (encoder).writeInt(((Integer) data.get(836))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(837))); + (encoder).writeInt(((Integer) data.get(838))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(839))); + (encoder).writeInt(((Integer) data.get(840))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(841))); + (encoder).writeInt(((Integer) data.get(842))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(843))); + (encoder).writeInt(((Integer) data.get(844))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(845))); + (encoder).writeInt(((Integer) data.get(846))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(847))); + (encoder).writeInt(((Integer) data.get(848))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(849))); + (encoder).writeInt(((Integer) data.get(850))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(851))); + (encoder).writeInt(((Integer) data.get(852))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(853))); + (encoder).writeInt(((Integer) data.get(854))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(855))); + (encoder).writeInt(((Integer) data.get(856))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(857))); + (encoder).writeInt(((Integer) data.get(858))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(859))); + (encoder).writeInt(((Integer) data.get(860))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(861))); + (encoder).writeInt(((Integer) data.get(862))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(863))); + (encoder).writeInt(((Integer) data.get(864))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(865))); + (encoder).writeInt(((Integer) data.get(866))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(867))); + (encoder).writeInt(((Integer) data.get(868))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(869))); + (encoder).writeInt(((Integer) data.get(870))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(871))); + (encoder).writeInt(((Integer) data.get(872))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(873))); + (encoder).writeInt(((Integer) data.get(874))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(875))); + (encoder).writeInt(((Integer) data.get(876))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(877))); + (encoder).writeInt(((Integer) data.get(878))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(879))); + (encoder).writeInt(((Integer) data.get(880))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(881))); + (encoder).writeInt(((Integer) data.get(882))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(883))); + (encoder).writeInt(((Integer) data.get(884))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(885))); + (encoder).writeInt(((Integer) data.get(886))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(887))); + (encoder).writeInt(((Integer) data.get(888))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(889))); + (encoder).writeInt(((Integer) data.get(890))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(891))); + (encoder).writeInt(((Integer) data.get(892))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(893))); + (encoder).writeInt(((Integer) data.get(894))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(895))); + (encoder).writeInt(((Integer) data.get(896))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(897))); + (encoder).writeInt(((Integer) data.get(898))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(899))); + (encoder).writeInt(((Integer) data.get(900))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(901))); + (encoder).writeInt(((Integer) data.get(902))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(903))); + (encoder).writeInt(((Integer) data.get(904))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(905))); + (encoder).writeInt(((Integer) data.get(906))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(907))); + (encoder).writeInt(((Integer) data.get(908))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(909))); + (encoder).writeInt(((Integer) data.get(910))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(911))); + (encoder).writeInt(((Integer) data.get(912))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(913))); + (encoder).writeInt(((Integer) data.get(914))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(915))); + (encoder).writeInt(((Integer) data.get(916))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(917))); + (encoder).writeInt(((Integer) data.get(918))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(919))); + (encoder).writeInt(((Integer) data.get(920))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(921))); + (encoder).writeInt(((Integer) data.get(922))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(923))); + (encoder).writeInt(((Integer) data.get(924))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(925))); + (encoder).writeInt(((Integer) data.get(926))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(927))); + (encoder).writeInt(((Integer) data.get(928))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(929))); + (encoder).writeInt(((Integer) data.get(930))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(931))); + (encoder).writeInt(((Integer) data.get(932))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(933))); + (encoder).writeInt(((Integer) data.get(934))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(935))); + (encoder).writeInt(((Integer) data.get(936))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(937))); + (encoder).writeInt(((Integer) data.get(938))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(939))); + (encoder).writeInt(((Integer) data.get(940))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(941))); + (encoder).writeInt(((Integer) data.get(942))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(943))); + (encoder).writeInt(((Integer) data.get(944))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(945))); + (encoder).writeInt(((Integer) data.get(946))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(947))); + (encoder).writeInt(((Integer) data.get(948))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(949))); + (encoder).writeInt(((Integer) data.get(950))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(951))); + (encoder).writeInt(((Integer) data.get(952))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(953))); + (encoder).writeInt(((Integer) data.get(954))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(955))); + (encoder).writeInt(((Integer) data.get(956))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(957))); + (encoder).writeInt(((Integer) data.get(958))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(959))); + (encoder).writeInt(((Integer) data.get(960))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(961))); + (encoder).writeInt(((Integer) data.get(962))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(963))); + (encoder).writeInt(((Integer) data.get(964))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(965))); + (encoder).writeInt(((Integer) data.get(966))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(967))); + (encoder).writeInt(((Integer) data.get(968))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(969))); + (encoder).writeInt(((Integer) data.get(970))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(971))); + (encoder).writeInt(((Integer) data.get(972))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(973))); + (encoder).writeInt(((Integer) data.get(974))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(975))); + (encoder).writeInt(((Integer) data.get(976))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(977))); + (encoder).writeInt(((Integer) data.get(978))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(979))); + (encoder).writeInt(((Integer) data.get(980))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(981))); + (encoder).writeInt(((Integer) data.get(982))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(983))); + (encoder).writeInt(((Integer) data.get(984))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(985))); + (encoder).writeInt(((Integer) data.get(986))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(987))); + (encoder).writeInt(((Integer) data.get(988))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(989))); + (encoder).writeInt(((Integer) data.get(990))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(991))); + (encoder).writeInt(((Integer) data.get(992))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(993))); + (encoder).writeInt(((Integer) data.get(994))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(995))); + (encoder).writeInt(((Integer) data.get(996))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(997))); + (encoder).writeInt(((Integer) data.get(998))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(999))); + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java new file mode 100644 index 000000000..4ae4e108c --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java @@ -0,0 +1,116 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + int valueToWrite0; + Object enumValue0 = data.get(0); + if (enumValue0 instanceof Enum) { + valueToWrite0 = ((Enum) enumValue0).ordinal(); + } else { + valueToWrite0 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).toString()); + } + (encoder).writeEnum(valueToWrite0); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + GenericEnumSymbol testEnumUnion0 = ((GenericEnumSymbol) data.get(1)); + if (testEnumUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((testEnumUnion0 instanceof GenericEnumSymbol)&&"com.linkedin.avro.fastserde.generated.avro.testEnum".equals(((GenericEnumSymbol) testEnumUnion0).getSchema().getFullName())) { + (encoder).writeIndex(1); + int valueToWrite1; + Object enumValue1 = testEnumUnion0; + if (enumValue1 instanceof Enum) { + valueToWrite1 = ((Enum) enumValue1).ordinal(); + } else { + valueToWrite1 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).toString()); + } + (encoder).writeEnum(valueToWrite1); + } + } + List testEnumArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testEnumArray0 == null)||testEnumArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testEnumArray0 .size()); + for (int counter0 = 0; (counter0 testEnumUnionArray0 = ((List ) data.get(3)); + (encoder).writeArrayStart(); + if ((testEnumUnionArray0 == null)||testEnumUnionArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testEnumUnionArray0 .size()); + for (int counter1 = 0; (counter1 ) testEnumUnionArray0).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof GenericEnumSymbol)&&"com.linkedin.avro.fastserde.generated.avro.testEnum".equals(((GenericEnumSymbol) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + int valueToWrite3; + Object enumValue3 = union0; + if (enumValue3 instanceof Enum) { + valueToWrite3 = ((Enum) enumValue3).ordinal(); + } else { + valueToWrite3 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue3).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue3).toString()); + } + (encoder).writeEnum(valueToWrite3); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java new file mode 100644 index 000000000..ec8422775 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java @@ -0,0 +1,88 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + GenericFixed testFixedUnion0 = ((GenericFixed) data.get(1)); + if (testFixedUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((testFixedUnion0 instanceof GenericFixed)&&"com.linkedin.avro.fastserde.generated.avro.testFixed".equals(((GenericFixed) testFixedUnion0).getSchema().getFullName())) { + (encoder).writeIndex(1); + (encoder).writeFixed(((GenericFixed) testFixedUnion0).bytes()); + } + } + List testFixedArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testFixedArray0 == null)||testFixedArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testFixedArray0 .size()); + for (int counter0 = 0; (counter0 testFixedUnionArray0 = ((List ) data.get(3)); + (encoder).writeArrayStart(); + if ((testFixedUnionArray0 == null)||testFixedUnionArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testFixedUnionArray0 .size()); + for (int counter1 = 0; (counter1 ) testFixedUnionArray0).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof GenericFixed)&&"com.linkedin.avro.fastserde.generated.avro.testFixed".equals(((GenericFixed) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + (encoder).writeFixed(((GenericFixed) union0).bytes()); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java new file mode 100644 index 000000000..f0ade5ee6 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java @@ -0,0 +1,70 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object union0 = ((Object) data.get(0)); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } else { + if (union0 instanceof CharSequence) { + (encoder).writeIndex(2); + if (((CharSequence) union0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) union0))); + } else { + (encoder).writeString(((CharSequence) union0).toString()); + } + } else { + if (union0 instanceof Integer) { + (encoder).writeIndex(3); + (encoder).writeInt(((Integer) union0)); + } + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java new file mode 100644 index 000000000..2b3d56844 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java @@ -0,0 +1,157 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import java.nio.ByteBuffer; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Integer testIntUnion0 = ((Integer) data.get(1)); + if (testIntUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeInt(((Integer) testIntUnion0)); + } + Integer testFlippedIntUnion0 = ((Integer) data.get(2)); + if (testFlippedIntUnion0 == null) { + (encoder).writeIndex(1); + (encoder).writeNull(); + } else { + (encoder).writeIndex(0); + (encoder).writeInt(((Integer) testFlippedIntUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(3)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(3)))); + } else { + (encoder).writeString(((CharSequence) data.get(3)).toString()); + } + CharSequence testStringUnion0 = ((CharSequence) data.get(4)); + if (testStringUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testStringUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringUnion0))); + } else { + (encoder).writeString(((CharSequence) testStringUnion0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeLong(((Long) data.get(5))); + Long testLongUnion0 = ((Long) data.get(6)); + if (testLongUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeLong(((Long) testLongUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeDouble(((Double) data.get(7))); + Double testDoubleUnion0 = ((Double) data.get(8)); + if (testDoubleUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeDouble(((Double) testDoubleUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFloat(((Float) data.get(9))); + Float testFloatUnion0 = ((Float) data.get(10)); + if (testFloatUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeFloat(((Float) testFloatUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeBoolean(((Boolean) data.get(11))); + Boolean testBooleanUnion0 = ((Boolean) data.get(12)); + if (testBooleanUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeBoolean(((Boolean) testBooleanUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeBytes(((ByteBuffer) data.get(13))); + ByteBuffer testBytesUnion0 = ((ByteBuffer) data.get(14)); + if (testBytesUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeBytes(((ByteBuffer) testBytesUnion0)); + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java new file mode 100644 index 000000000..cfdf0ad77 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object union_field0 = ((Object) data.get(0)); + if (union_field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record1".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord10(((IndexedRecord) union_field0), (encoder), (customization)); + } else { + if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record2".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { + (encoder).writeIndex(2); + serializeRecord20(((IndexedRecord) union_field0), (encoder), (customization)); + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + } + + @SuppressWarnings("unchecked") + public void serializeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java new file mode 100644 index 000000000..494b57134 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java @@ -0,0 +1,158 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List recordsArray0 = ((List ) data.get(0)); + (encoder).writeArrayStart(); + if ((recordsArray0 == null)||recordsArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsArray0 .size()); + for (int counter0 = 0; (counter0 ) recordsArray0).get(counter0); + serializeSubRecord0(subRecord0, (encoder), (customization)); + } + } + (encoder).writeArrayEnd(); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map recordsMap0 = ((Map ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMap0); + } + (encoder).writeMapStart(); + if ((recordsMap0 == null)||recordsMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsMap0 .size()); + for (CharSequence key0 : ((Map ) recordsMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord subRecord1 = null; + subRecord1 = ((Map ) recordsMap0).get(key0); + serializeSubRecord0(subRecord1, (encoder), (customization)); + } + } + (encoder).writeMapEnd(); + List recordsArrayUnion0 = ((List ) data.get(2)); + if (recordsArrayUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsArrayUnion0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) recordsArrayUnion0) == null)||((List ) recordsArrayUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) recordsArrayUnion0).size()); + for (int counter1 = 0; (counter1 <((List ) recordsArrayUnion0).size()); counter1 ++) { + (encoder).startItem(); + IndexedRecord union0 = null; + union0 = ((List )((List ) recordsArrayUnion0)).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map recordsMapUnion0 = ((Map ) data.get(3)); + if (recordsMapUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsMapUnion0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map ) recordsMapUnion0)); + } + (encoder).writeMapStart(); + if ((((Map ) recordsMapUnion0) == null)||((Map ) recordsMapUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map ) recordsMapUnion0).size()); + for (CharSequence key1 : ((Map )((Map ) recordsMapUnion0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + IndexedRecord union1 = null; + union1 = ((Map )((Map ) recordsMapUnion0)).get(key1); + if (union1 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java new file mode 100644 index 000000000..e1132ea20 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java @@ -0,0 +1,230 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List> recordsArrayMap0 = ((List> ) data.get(0)); + (encoder).writeArrayStart(); + if ((recordsArrayMap0 == null)||recordsArrayMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsArrayMap0 .size()); + for (int counter0 = 0; (counter0 map0 = null; + map0 = ((List> ) recordsArrayMap0).get(counter0); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map0); + } + (encoder).writeMapStart(); + if ((map0 == null)||map0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(map0 .size()); + for (CharSequence key0 : ((Map ) map0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord union0 = null; + union0 = ((Map ) map0).get(key0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + (encoder).writeArrayEnd(); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map> recordsMapArray0 = ((Map> ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMapArray0); + } + (encoder).writeMapStart(); + if ((recordsMapArray0 == null)||recordsMapArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsMapArray0 .size()); + for (CharSequence key1 : ((Map> ) recordsMapArray0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + List array0 = null; + array0 = ((Map> ) recordsMapArray0).get(key1); + (encoder).writeArrayStart(); + if ((array0 == null)||array0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array0 .size()); + for (int counter1 = 0; (counter1 ) array0).get(counter1); + if (union1 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + (encoder).writeMapEnd(); + List> recordsArrayMapUnion0 = ((List> ) data.get(2)); + if (recordsArrayMapUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsArrayMapUnion0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List> ) recordsArrayMapUnion0) == null)||((List> ) recordsArrayMapUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List> ) recordsArrayMapUnion0).size()); + for (int counter2 = 0; (counter2 <((List> ) recordsArrayMapUnion0).size()); counter2 ++) { + (encoder).startItem(); + Map map1 = null; + map1 = ((List> )((List> ) recordsArrayMapUnion0)).get(counter2); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map1); + } + (encoder).writeMapStart(); + if ((map1 == null)||map1 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(map1 .size()); + for (CharSequence key2 : ((Map ) map1).keySet()) { + (encoder).startItem(); + (encoder).writeString(key2); + IndexedRecord union2 = null; + union2 = ((Map ) map1).get(key2); + if (union2 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union2 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union2).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union2), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + (encoder).writeArrayEnd(); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map> recordsMapArrayUnion0 = ((Map> ) data.get(3)); + if (recordsMapArrayUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsMapArrayUnion0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map> ) recordsMapArrayUnion0)); + } + (encoder).writeMapStart(); + if ((((Map> ) recordsMapArrayUnion0) == null)||((Map> ) recordsMapArrayUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map> ) recordsMapArrayUnion0).size()); + for (CharSequence key3 : ((Map> )((Map> ) recordsMapArrayUnion0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key3); + List array1 = null; + array1 = ((Map> )((Map> ) recordsMapArrayUnion0)).get(key3); + (encoder).writeArrayStart(); + if ((array1 == null)||array1 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array1 .size()); + for (int counter3 = 0; (counter3 ) array1).get(counter3); + if (union3 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union3 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union3).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union3), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + (encoder).writeMapEnd(); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java new file mode 100644 index 000000000..842de6e59 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + IndexedRecord record0 = ((IndexedRecord) data.get(0)); + if (record0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((record0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) record0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) record0), (encoder), (customization)); + } + } + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + IndexedRecord record10 = ((IndexedRecord) data.get(1)); + serializeSubRecord0(record10, (encoder), (customization)); + CharSequence field0 = ((CharSequence) data.get(2)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastSerdeEnums_GenericSerializer_957378572.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastSerdeEnums_GenericSerializer_957378572.java new file mode 100644 index 000000000..a40332169 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastSerdeEnums_GenericSerializer_957378572.java @@ -0,0 +1,95 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeEnums_GenericSerializer_957378572 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + int valueToWrite0; + Object enumValue0 = data.get(0); + if (enumValue0 instanceof Enum) { + valueToWrite0 = ((Enum) enumValue0).ordinal(); + } else { + valueToWrite0 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).toString()); + } + (encoder).writeEnum(valueToWrite0); + serialize_FastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List arrayOfEnums0 = ((List ) data.get(1)); + if (arrayOfEnums0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (arrayOfEnums0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) arrayOfEnums0) == null)||((List ) arrayOfEnums0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) arrayOfEnums0).size()); + for (int counter0 = 0; (counter0 <((List ) arrayOfEnums0).size()); counter0 ++) { + (encoder).startItem(); + int valueToWrite1; + Object enumValue1 = ((List ) arrayOfEnums0).get(counter0); + if (enumValue1 instanceof Enum) { + valueToWrite1 = ((Enum) enumValue1).ordinal(); + } else { + valueToWrite1 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).toString()); + } + (encoder).writeEnum(valueToWrite1); + } + } + (encoder).writeArrayEnd(); + } + } + Map mapOfEnums0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfEnums0); + } + (encoder).writeMapStart(); + if ((mapOfEnums0 == null)||mapOfEnums0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfEnums0 .size()); + for (CharSequence key0 : ((Map ) mapOfEnums0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + int valueToWrite2; + Object enumValue2 = mapOfEnums0 .get(key0); + if (enumValue2 instanceof Enum) { + valueToWrite2 = ((Enum) enumValue2).ordinal(); + } else { + valueToWrite2 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue2).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue2).toString()); + } + (encoder).writeEnum(valueToWrite2); + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastSerdeFixed_GenericSerializer_504108934.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastSerdeFixed_GenericSerializer_504108934.java new file mode 100644 index 000000000..41699d954 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastSerdeFixed_GenericSerializer_504108934.java @@ -0,0 +1,74 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeFixed_GenericSerializer_504108934 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List arrayOfFixed0 = ((List ) data.get(1)); + if (arrayOfFixed0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (arrayOfFixed0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) arrayOfFixed0) == null)||((List ) arrayOfFixed0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) arrayOfFixed0).size()); + for (int counter0 = 0; (counter0 <((List ) arrayOfFixed0).size()); counter0 ++) { + (encoder).startItem(); + (encoder).writeFixed(((GenericFixed)((List ) arrayOfFixed0).get(counter0)).bytes()); + } + } + (encoder).writeArrayEnd(); + } + } + Map mapOfFixed0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfFixed0); + } + (encoder).writeMapStart(); + if ((mapOfFixed0 == null)||mapOfFixed0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfFixed0 .size()); + for (CharSequence key0 : ((Map ) mapOfFixed0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + (encoder).writeFixed(((GenericFixed) mapOfFixed0 .get(key0)).bytes()); + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java new file mode 100644 index 000000000..dae6fb2f8 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java @@ -0,0 +1,97 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence testUnionString0 = ((CharSequence) data.get(1)); + if (testUnionString0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testUnionString0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testUnionString0))); + } else { + (encoder).writeString(((CharSequence) testUnionString0).toString()); + } + } + List testStringArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testStringArray0 == null)||testStringArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringArray0 .size()); + for (int counter0 = 0; (counter0 testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } + (encoder).writeMapStart(); + if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringMap0 .size()); + for (CharSequence key0 : ((Map ) testStringMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) testStringMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) testStringMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java new file mode 100644 index 000000000..c93145ab5 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java @@ -0,0 +1,97 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_FastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence testUnionString0 = ((CharSequence) data.get(1)); + if (testUnionString0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testUnionString0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testUnionString0))); + } else { + (encoder).writeString(((CharSequence) testUnionString0).toString()); + } + } + List testStringArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testStringArray0 == null)||testStringArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringArray0 .size()); + for (int counter0 = 0; (counter0 testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } + (encoder).writeMapStart(); + if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringMap0 .size()); + for (CharSequence key0 : ((Map ) testStringMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) testStringMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) testStringMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/Map_of_UNION_GenericSerializer_2140000109.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/Map_of_UNION_GenericSerializer_2140000109.java new file mode 100644 index 000000000..278a922f7 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/Map_of_UNION_GenericSerializer_2140000109.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Map_of_UNION_GenericSerializer_2140000109 + implements FastSerializer> +{ + + + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } + (encoder).writeMapStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (CharSequence key0 : ((Map ) data).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord union0 = null; + union0 = ((Map ) data).get(key0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/Map_of_record_GenericSerializer_1677529043.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/Map_of_record_GenericSerializer_1677529043.java new file mode 100644 index 000000000..f813fd327 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/Map_of_record_GenericSerializer_1677529043.java @@ -0,0 +1,57 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Map_of_record_GenericSerializer_1677529043 + implements FastSerializer> +{ + + + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } + (encoder).writeMapStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (CharSequence key0 : ((Map ) data).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord record0 = null; + record0 = ((Map ) data).get(key0); + serializeRecord0(record0, (encoder), (customization)); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/StringableRecord_SpecificSerializer_842267318.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/StringableRecord_SpecificSerializer_842267318.java new file mode 100644 index 000000000..5ed569362 --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/StringableRecord_SpecificSerializer_842267318.java @@ -0,0 +1,189 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord; +import com.linkedin.avro.fastserde.generated.avro.StringableRecord; +import com.linkedin.avro.fastserde.generated.avro.StringableSubRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class StringableRecord_SpecificSerializer_842267318 + implements FastSerializer +{ + + + public void serialize(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeStringableRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_StringableRecord0(data, (encoder), (customization)); + serialize_StringableRecord1(data, (encoder), (customization)); + serialize_StringableRecord2(data, (encoder), (customization)); + serialize_StringableRecord3(data, (encoder), (customization)); + serialize_StringableRecord4(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(1)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(1)))); + } else { + (encoder).writeString(((CharSequence) data.get(1)).toString()); + } + if (((CharSequence) data.get(2)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(2)))); + } else { + (encoder).writeString(((CharSequence) data.get(2)).toString()); + } + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord1(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(3)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(3)))); + } else { + (encoder).writeString(((CharSequence) data.get(3)).toString()); + } + if (((CharSequence) data.get(4)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(4)))); + } else { + (encoder).writeString(((CharSequence) data.get(4)).toString()); + } + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord2(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List urlArray0 = ((List ) data.get(5)); + (encoder).writeArrayStart(); + if ((urlArray0 == null)||urlArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(urlArray0 .size()); + for (int counter0 = 0; (counter0 urlMap0 = ((Map ) data.get(6)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(urlMap0); + } + (encoder).writeMapStart(); + if ((urlMap0 == null)||urlMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(urlMap0 .size()); + for (CharSequence key0 : ((Map ) urlMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) urlMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) urlMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) urlMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord3(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord0 = ((StringableSubRecord) data.get(7)); + serializeStringableSubRecord0(subRecord0, (encoder), (customization)); + AnotherSubRecord subRecordWithSubRecord0 = ((AnotherSubRecord) data.get(8)); + serializeAnotherSubRecord0(subRecordWithSubRecord0, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_StringableSubRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object nullStringIntUnion0 = ((Object) data.get(1)); + if (nullStringIntUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (nullStringIntUnion0 instanceof CharSequence) { + (encoder).writeIndex(1); + if (((CharSequence) nullStringIntUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) nullStringIntUnion0))); + } else { + (encoder).writeString(((CharSequence) nullStringIntUnion0).toString()); + } + } else { + if (nullStringIntUnion0 instanceof Integer) { + (encoder).writeIndex(2); + (encoder).writeInt(((Integer) nullStringIntUnion0)); + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeAnotherSubRecord0(AnotherSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord1 = ((StringableSubRecord) data.get(0)); + serializeStringableSubRecord0(subRecord1, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord4(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence stringUnion0 = ((CharSequence) data.get(9)); + if (stringUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) stringUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) stringUnion0))); + } else { + (encoder).writeString(((CharSequence) stringUnion0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/TestArrayOfFloats_GenericSerializer_1408566797.java b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/TestArrayOfFloats_GenericSerializer_1408566797.java new file mode 100644 index 000000000..4a9ed2aab --- /dev/null +++ b/fastserde/avro-fastserde-tests15/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_5/TestArrayOfFloats_GenericSerializer_1408566797.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_5; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class TestArrayOfFloats_GenericSerializer_1408566797 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeTestArrayOfFloats0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeTestArrayOfFloats0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List array_of_float0 = ((List ) data.get(0)); + (encoder).writeArrayStart(); + if ((array_of_float0 == null)||array_of_float0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array_of_float0 .size()); + Object array0 = array_of_float0; + if (array0 instanceof PrimitiveFloatList) { + PrimitiveFloatList primitiveList0 = ((PrimitiveFloatList) array0); + if (primitiveList0 instanceof BufferBackedPrimitiveFloatList) { + BufferBackedPrimitiveFloatList bufferBackedPrimitiveFloatList = ((BufferBackedPrimitiveFloatList) primitiveList0); + bufferBackedPrimitiveFloatList.writeFloats((encoder)); + } else { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_BOOLEAN_GenericDeserializer_869749973_869749973(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveBooleanList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveBooleanList) { + array0 = ((PrimitiveBooleanList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveBooleanArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_DOUBLE_GenericDeserializer_18760307_18760307(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveDoubleList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveDoubleList) { + array0 = ((PrimitiveDoubleList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveDoubleArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_FLOAT_GenericDeserializer_1012670397_1012670397(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveFloatList array0 = null; + array0 = ((PrimitiveFloatList) BufferBackedPrimitiveFloatList.readPrimitiveFloatArray((reuse), (decoder))); + return array0; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/Array_of_INT_GenericDeserializer_1012089072_1012089072.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/Array_of_INT_GenericDeserializer_1012089072_1012089072.java new file mode 100644 index 000000000..6540132ce --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/Array_of_INT_GenericDeserializer_1012089072_1012089072.java @@ -0,0 +1,43 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class Array_of_INT_GenericDeserializer_1012089072_1012089072 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Array_of_INT_GenericDeserializer_1012089072_1012089072(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveIntList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveIntList) { + array0 = ((PrimitiveIntList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_LONG_GenericDeserializer_325099267_325099267(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveLongList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveLongList) { + array0 = ((PrimitiveLongList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveLongArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_TestRecord_SpecificDeserializer_1088113243_1088113243(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema arrayArrayElemSchema0; + private final Schema arrayElemOptionSchema0; + private final Schema field0; + + public Array_of_UNION_GenericDeserializer_777827233_777827233(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArrayElemSchema0 = readerSchema.getElementType(); + this.arrayElemOptionSchema0 = arrayArrayElemSchema0 .getTypes().get(1); + this.field0 = arrayElemOptionSchema0 .getField("field").schema(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_UNION_SpecificDeserializer_1277939469_1277939469(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex15 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex17)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex21 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex21)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex23 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex23)); + } + } + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex25 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex25 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex25 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex25)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema unionOptionArrayElemSchema0; + + public Array_of_record_GenericDeserializer_1606337179_2018567528(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOptionArrayElemSchema0 = readerSchema.getElementType(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":{\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}}"); + } else { + if (unionIndex0 == 1) { + List unionOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + unionOption0 = ((List)(reuse)); + unionOption0 .clear(); + } else { + unionOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + private final Schema arrayArrayElemSchema0; + private final Schema field0; + + public Array_of_record_GenericDeserializer_477614132_477614132(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArrayElemSchema0 = readerSchema.getElementType(); + this.field0 = arrayArrayElemSchema0 .getField("field").schema(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema f00; + private final Schema f10; + private final Schema f20; + private final Schema f30; + private final Schema f40; + private final Schema f50; + private final Schema f60; + private final Schema f70; + private final Schema f80; + private final Schema f90; + private final Schema f100; + private final Schema f110; + private final Schema f120; + private final Schema f130; + private final Schema f140; + private final Schema f150; + private final Schema f160; + private final Schema f170; + private final Schema f180; + private final Schema f190; + private final Schema f200; + private final Schema f210; + private final Schema f220; + private final Schema f230; + private final Schema f240; + private final Schema f250; + private final Schema f260; + private final Schema f270; + private final Schema f280; + private final Schema f290; + private final Schema f300; + private final Schema f310; + private final Schema f320; + private final Schema f330; + private final Schema f340; + private final Schema f350; + private final Schema f360; + private final Schema f370; + private final Schema f380; + private final Schema f390; + private final Schema f400; + private final Schema f410; + private final Schema f420; + private final Schema f430; + private final Schema f440; + private final Schema f450; + private final Schema f460; + private final Schema f470; + private final Schema f480; + private final Schema f490; + private final Schema f500; + private final Schema f510; + private final Schema f520; + private final Schema f530; + private final Schema f540; + private final Schema f550; + private final Schema f560; + private final Schema f570; + private final Schema f580; + private final Schema f590; + private final Schema f600; + private final Schema f610; + private final Schema f620; + private final Schema f630; + private final Schema f640; + private final Schema f650; + private final Schema f660; + private final Schema f670; + private final Schema f680; + private final Schema f690; + private final Schema f700; + private final Schema f710; + private final Schema f720; + private final Schema f730; + private final Schema f740; + private final Schema f750; + private final Schema f760; + private final Schema f770; + private final Schema f780; + private final Schema f790; + private final Schema f800; + private final Schema f810; + private final Schema f820; + private final Schema f830; + private final Schema f840; + private final Schema f850; + private final Schema f860; + private final Schema f870; + private final Schema f880; + private final Schema f890; + private final Schema f900; + private final Schema f910; + private final Schema f920; + private final Schema f930; + private final Schema f940; + private final Schema f950; + private final Schema f960; + private final Schema f970; + private final Schema f980; + private final Schema f990; + private final Schema f1000; + private final Schema f1010; + private final Schema f1020; + private final Schema f1030; + private final Schema f1040; + private final Schema f1050; + private final Schema f1060; + private final Schema f1070; + private final Schema f1080; + private final Schema f1090; + private final Schema f1100; + private final Schema f1110; + private final Schema f1120; + private final Schema f1130; + private final Schema f1140; + private final Schema f1150; + private final Schema f1160; + private final Schema f1170; + private final Schema f1180; + private final Schema f1190; + private final Schema f1200; + private final Schema f1210; + private final Schema f1220; + private final Schema f1230; + private final Schema f1240; + private final Schema f1250; + private final Schema f1260; + private final Schema f1270; + private final Schema f1280; + private final Schema f1290; + private final Schema f1300; + private final Schema f1310; + private final Schema f1320; + private final Schema f1330; + private final Schema f1340; + private final Schema f1350; + private final Schema f1360; + private final Schema f1370; + private final Schema f1380; + private final Schema f1390; + private final Schema f1400; + private final Schema f1410; + private final Schema f1420; + private final Schema f1430; + private final Schema f1440; + private final Schema f1450; + private final Schema f1460; + private final Schema f1470; + private final Schema f1480; + private final Schema f1490; + private final Schema f1500; + private final Schema f1510; + private final Schema f1520; + private final Schema f1530; + private final Schema f1540; + private final Schema f1550; + private final Schema f1560; + private final Schema f1570; + private final Schema f1580; + private final Schema f1590; + private final Schema f1600; + private final Schema f1610; + private final Schema f1620; + private final Schema f1630; + private final Schema f1640; + private final Schema f1650; + private final Schema f1660; + private final Schema f1670; + private final Schema f1680; + private final Schema f1690; + private final Schema f1700; + private final Schema f1710; + private final Schema f1720; + private final Schema f1730; + private final Schema f1740; + private final Schema f1750; + private final Schema f1760; + private final Schema f1770; + private final Schema f1780; + private final Schema f1790; + private final Schema f1800; + private final Schema f1810; + private final Schema f1820; + private final Schema f1830; + private final Schema f1840; + private final Schema f1850; + private final Schema f1860; + private final Schema f1870; + private final Schema f1880; + private final Schema f1890; + private final Schema f1900; + private final Schema f1910; + private final Schema f1920; + private final Schema f1930; + private final Schema f1940; + private final Schema f1950; + private final Schema f1960; + private final Schema f1970; + private final Schema f1980; + private final Schema f1990; + private final Schema f2000; + private final Schema f2010; + private final Schema f2020; + private final Schema f2030; + private final Schema f2040; + private final Schema f2050; + private final Schema f2060; + private final Schema f2070; + private final Schema f2080; + private final Schema f2090; + private final Schema f2100; + private final Schema f2110; + private final Schema f2120; + private final Schema f2130; + private final Schema f2140; + private final Schema f2150; + private final Schema f2160; + private final Schema f2170; + private final Schema f2180; + private final Schema f2190; + private final Schema f2200; + private final Schema f2210; + private final Schema f2220; + private final Schema f2230; + private final Schema f2240; + private final Schema f2250; + private final Schema f2260; + private final Schema f2270; + private final Schema f2280; + private final Schema f2290; + private final Schema f2300; + private final Schema f2310; + private final Schema f2320; + private final Schema f2330; + private final Schema f2340; + private final Schema f2350; + private final Schema f2360; + private final Schema f2370; + private final Schema f2380; + private final Schema f2390; + private final Schema f2400; + private final Schema f2410; + private final Schema f2420; + private final Schema f2430; + private final Schema f2440; + private final Schema f2450; + private final Schema f2460; + private final Schema f2470; + private final Schema f2480; + private final Schema f2490; + private final Schema f2500; + private final Schema f2510; + private final Schema f2520; + private final Schema f2530; + private final Schema f2540; + private final Schema f2550; + private final Schema f2560; + private final Schema f2570; + private final Schema f2580; + private final Schema f2590; + private final Schema f2600; + private final Schema f2610; + private final Schema f2620; + private final Schema f2630; + private final Schema f2640; + private final Schema f2650; + private final Schema f2660; + private final Schema f2670; + private final Schema f2680; + private final Schema f2690; + private final Schema f2700; + private final Schema f2710; + private final Schema f2720; + private final Schema f2730; + private final Schema f2740; + private final Schema f2750; + private final Schema f2760; + private final Schema f2770; + private final Schema f2780; + private final Schema f2790; + private final Schema f2800; + private final Schema f2810; + private final Schema f2820; + private final Schema f2830; + private final Schema f2840; + private final Schema f2850; + private final Schema f2860; + private final Schema f2870; + private final Schema f2880; + private final Schema f2890; + private final Schema f2900; + private final Schema f2910; + private final Schema f2920; + private final Schema f2930; + private final Schema f2940; + private final Schema f2950; + private final Schema f2960; + private final Schema f2970; + private final Schema f2980; + private final Schema f2990; + private final Schema f3000; + private final Schema f3010; + private final Schema f3020; + private final Schema f3030; + private final Schema f3040; + private final Schema f3050; + private final Schema f3060; + private final Schema f3070; + private final Schema f3080; + private final Schema f3090; + private final Schema f3100; + private final Schema f3110; + private final Schema f3120; + private final Schema f3130; + private final Schema f3140; + private final Schema f3150; + private final Schema f3160; + private final Schema f3170; + private final Schema f3180; + private final Schema f3190; + private final Schema f3200; + private final Schema f3210; + private final Schema f3220; + private final Schema f3230; + private final Schema f3240; + private final Schema f3250; + private final Schema f3260; + private final Schema f3270; + private final Schema f3280; + private final Schema f3290; + private final Schema f3300; + private final Schema f3310; + private final Schema f3320; + private final Schema f3330; + private final Schema f3340; + private final Schema f3350; + private final Schema f3360; + private final Schema f3370; + private final Schema f3380; + private final Schema f3390; + private final Schema f3400; + private final Schema f3410; + private final Schema f3420; + private final Schema f3430; + private final Schema f3440; + private final Schema f3450; + private final Schema f3460; + private final Schema f3470; + private final Schema f3480; + private final Schema f3490; + private final Schema f3500; + private final Schema f3510; + private final Schema f3520; + private final Schema f3530; + private final Schema f3540; + private final Schema f3550; + private final Schema f3560; + private final Schema f3570; + private final Schema f3580; + private final Schema f3590; + private final Schema f3600; + private final Schema f3610; + private final Schema f3620; + private final Schema f3630; + private final Schema f3640; + private final Schema f3650; + private final Schema f3660; + private final Schema f3670; + private final Schema f3680; + private final Schema f3690; + private final Schema f3700; + private final Schema f3710; + private final Schema f3720; + private final Schema f3730; + private final Schema f3740; + private final Schema f3750; + private final Schema f3760; + private final Schema f3770; + private final Schema f3780; + private final Schema f3790; + private final Schema f3800; + private final Schema f3810; + private final Schema f3820; + private final Schema f3830; + private final Schema f3840; + private final Schema f3850; + private final Schema f3860; + private final Schema f3870; + private final Schema f3880; + private final Schema f3890; + private final Schema f3900; + private final Schema f3910; + private final Schema f3920; + private final Schema f3930; + private final Schema f3940; + private final Schema f3950; + private final Schema f3960; + private final Schema f3970; + private final Schema f3980; + private final Schema f3990; + private final Schema f4000; + private final Schema f4010; + private final Schema f4020; + private final Schema f4030; + private final Schema f4040; + private final Schema f4050; + private final Schema f4060; + private final Schema f4070; + private final Schema f4080; + private final Schema f4090; + private final Schema f4100; + private final Schema f4110; + private final Schema f4120; + private final Schema f4130; + private final Schema f4140; + private final Schema f4150; + private final Schema f4160; + private final Schema f4170; + private final Schema f4180; + private final Schema f4190; + private final Schema f4200; + private final Schema f4210; + private final Schema f4220; + private final Schema f4230; + private final Schema f4240; + private final Schema f4250; + private final Schema f4260; + private final Schema f4270; + private final Schema f4280; + private final Schema f4290; + private final Schema f4300; + private final Schema f4310; + private final Schema f4320; + private final Schema f4330; + private final Schema f4340; + private final Schema f4350; + private final Schema f4360; + private final Schema f4370; + private final Schema f4380; + private final Schema f4390; + private final Schema f4400; + private final Schema f4410; + private final Schema f4420; + private final Schema f4430; + private final Schema f4440; + private final Schema f4450; + private final Schema f4460; + private final Schema f4470; + private final Schema f4480; + private final Schema f4490; + private final Schema f4500; + private final Schema f4510; + private final Schema f4520; + private final Schema f4530; + private final Schema f4540; + private final Schema f4550; + private final Schema f4560; + private final Schema f4570; + private final Schema f4580; + private final Schema f4590; + private final Schema f4600; + private final Schema f4610; + private final Schema f4620; + private final Schema f4630; + private final Schema f4640; + private final Schema f4650; + private final Schema f4660; + private final Schema f4670; + private final Schema f4680; + private final Schema f4690; + private final Schema f4700; + private final Schema f4710; + private final Schema f4720; + private final Schema f4730; + private final Schema f4740; + private final Schema f4750; + private final Schema f4760; + private final Schema f4770; + private final Schema f4780; + private final Schema f4790; + private final Schema f4800; + private final Schema f4810; + private final Schema f4820; + private final Schema f4830; + private final Schema f4840; + private final Schema f4850; + private final Schema f4860; + private final Schema f4870; + private final Schema f4880; + private final Schema f4890; + private final Schema f4900; + private final Schema f4910; + private final Schema f4920; + private final Schema f4930; + private final Schema f4940; + private final Schema f4950; + private final Schema f4960; + private final Schema f4970; + private final Schema f4980; + private final Schema f4990; + private final Schema f5000; + private final Schema f5010; + private final Schema f5020; + private final Schema f5030; + private final Schema f5040; + private final Schema f5050; + private final Schema f5060; + private final Schema f5070; + private final Schema f5080; + private final Schema f5090; + private final Schema f5100; + private final Schema f5110; + private final Schema f5120; + private final Schema f5130; + private final Schema f5140; + private final Schema f5150; + private final Schema f5160; + private final Schema f5170; + private final Schema f5180; + private final Schema f5190; + private final Schema f5200; + private final Schema f5210; + private final Schema f5220; + private final Schema f5230; + private final Schema f5240; + private final Schema f5250; + private final Schema f5260; + private final Schema f5270; + private final Schema f5280; + private final Schema f5290; + private final Schema f5300; + private final Schema f5310; + private final Schema f5320; + private final Schema f5330; + private final Schema f5340; + private final Schema f5350; + private final Schema f5360; + private final Schema f5370; + private final Schema f5380; + private final Schema f5390; + private final Schema f5400; + private final Schema f5410; + private final Schema f5420; + private final Schema f5430; + private final Schema f5440; + private final Schema f5450; + private final Schema f5460; + private final Schema f5470; + private final Schema f5480; + private final Schema f5490; + private final Schema f5500; + private final Schema f5510; + private final Schema f5520; + private final Schema f5530; + private final Schema f5540; + private final Schema f5550; + private final Schema f5560; + private final Schema f5570; + private final Schema f5580; + private final Schema f5590; + private final Schema f5600; + private final Schema f5610; + private final Schema f5620; + private final Schema f5630; + private final Schema f5640; + private final Schema f5650; + private final Schema f5660; + private final Schema f5670; + private final Schema f5680; + private final Schema f5690; + private final Schema f5700; + private final Schema f5710; + private final Schema f5720; + private final Schema f5730; + private final Schema f5740; + private final Schema f5750; + private final Schema f5760; + private final Schema f5770; + private final Schema f5780; + private final Schema f5790; + private final Schema f5800; + private final Schema f5810; + private final Schema f5820; + private final Schema f5830; + private final Schema f5840; + private final Schema f5850; + private final Schema f5860; + private final Schema f5870; + private final Schema f5880; + private final Schema f5890; + private final Schema f5900; + private final Schema f5910; + private final Schema f5920; + private final Schema f5930; + private final Schema f5940; + private final Schema f5950; + private final Schema f5960; + private final Schema f5970; + private final Schema f5980; + private final Schema f5990; + private final Schema f6000; + private final Schema f6010; + private final Schema f6020; + private final Schema f6030; + private final Schema f6040; + private final Schema f6050; + private final Schema f6060; + private final Schema f6070; + private final Schema f6080; + private final Schema f6090; + private final Schema f6100; + private final Schema f6110; + private final Schema f6120; + private final Schema f6130; + private final Schema f6140; + private final Schema f6150; + private final Schema f6160; + private final Schema f6170; + private final Schema f6180; + private final Schema f6190; + private final Schema f6200; + private final Schema f6210; + private final Schema f6220; + private final Schema f6230; + private final Schema f6240; + private final Schema f6250; + private final Schema f6260; + private final Schema f6270; + private final Schema f6280; + private final Schema f6290; + private final Schema f6300; + private final Schema f6310; + private final Schema f6320; + private final Schema f6330; + private final Schema f6340; + private final Schema f6350; + private final Schema f6360; + private final Schema f6370; + private final Schema f6380; + private final Schema f6390; + private final Schema f6400; + private final Schema f6410; + private final Schema f6420; + private final Schema f6430; + private final Schema f6440; + private final Schema f6450; + private final Schema f6460; + private final Schema f6470; + private final Schema f6480; + private final Schema f6490; + private final Schema f6500; + private final Schema f6510; + private final Schema f6520; + private final Schema f6530; + private final Schema f6540; + private final Schema f6550; + private final Schema f6560; + private final Schema f6570; + private final Schema f6580; + private final Schema f6590; + private final Schema f6600; + private final Schema f6610; + private final Schema f6620; + private final Schema f6630; + private final Schema f6640; + private final Schema f6650; + private final Schema f6660; + private final Schema f6670; + private final Schema f6680; + private final Schema f6690; + private final Schema f6700; + private final Schema f6710; + private final Schema f6720; + private final Schema f6730; + private final Schema f6740; + private final Schema f6750; + private final Schema f6760; + private final Schema f6770; + private final Schema f6780; + private final Schema f6790; + private final Schema f6800; + private final Schema f6810; + private final Schema f6820; + private final Schema f6830; + private final Schema f6840; + private final Schema f6850; + private final Schema f6860; + private final Schema f6870; + private final Schema f6880; + private final Schema f6890; + private final Schema f6900; + private final Schema f6910; + private final Schema f6920; + private final Schema f6930; + private final Schema f6940; + private final Schema f6950; + private final Schema f6960; + private final Schema f6970; + private final Schema f6980; + private final Schema f6990; + private final Schema f7000; + private final Schema f7010; + private final Schema f7020; + private final Schema f7030; + private final Schema f7040; + private final Schema f7050; + private final Schema f7060; + private final Schema f7070; + private final Schema f7080; + private final Schema f7090; + private final Schema f7100; + private final Schema f7110; + private final Schema f7120; + private final Schema f7130; + private final Schema f7140; + private final Schema f7150; + private final Schema f7160; + private final Schema f7170; + private final Schema f7180; + private final Schema f7190; + private final Schema f7200; + private final Schema f7210; + private final Schema f7220; + private final Schema f7230; + private final Schema f7240; + private final Schema f7250; + private final Schema f7260; + private final Schema f7270; + private final Schema f7280; + private final Schema f7290; + private final Schema f7300; + private final Schema f7310; + private final Schema f7320; + private final Schema f7330; + private final Schema f7340; + private final Schema f7350; + private final Schema f7360; + private final Schema f7370; + private final Schema f7380; + private final Schema f7390; + private final Schema f7400; + private final Schema f7410; + private final Schema f7420; + private final Schema f7430; + private final Schema f7440; + private final Schema f7450; + private final Schema f7460; + private final Schema f7470; + private final Schema f7480; + private final Schema f7490; + private final Schema f7500; + private final Schema f7510; + private final Schema f7520; + private final Schema f7530; + private final Schema f7540; + private final Schema f7550; + private final Schema f7560; + private final Schema f7570; + private final Schema f7580; + private final Schema f7590; + private final Schema f7600; + private final Schema f7610; + private final Schema f7620; + private final Schema f7630; + private final Schema f7640; + private final Schema f7650; + private final Schema f7660; + private final Schema f7670; + private final Schema f7680; + private final Schema f7690; + private final Schema f7700; + private final Schema f7710; + private final Schema f7720; + private final Schema f7730; + private final Schema f7740; + private final Schema f7750; + private final Schema f7760; + private final Schema f7770; + private final Schema f7780; + private final Schema f7790; + private final Schema f7800; + private final Schema f7810; + private final Schema f7820; + private final Schema f7830; + private final Schema f7840; + private final Schema f7850; + private final Schema f7860; + private final Schema f7870; + private final Schema f7880; + private final Schema f7890; + private final Schema f7900; + private final Schema f7910; + private final Schema f7920; + private final Schema f7930; + private final Schema f7940; + private final Schema f7950; + private final Schema f7960; + private final Schema f7970; + private final Schema f7980; + private final Schema f7990; + private final Schema f8000; + private final Schema f8010; + private final Schema f8020; + private final Schema f8030; + private final Schema f8040; + private final Schema f8050; + private final Schema f8060; + private final Schema f8070; + private final Schema f8080; + private final Schema f8090; + private final Schema f8100; + private final Schema f8110; + private final Schema f8120; + private final Schema f8130; + private final Schema f8140; + private final Schema f8150; + private final Schema f8160; + private final Schema f8170; + private final Schema f8180; + private final Schema f8190; + private final Schema f8200; + private final Schema f8210; + private final Schema f8220; + private final Schema f8230; + private final Schema f8240; + private final Schema f8250; + private final Schema f8260; + private final Schema f8270; + private final Schema f8280; + private final Schema f8290; + private final Schema f8300; + private final Schema f8310; + private final Schema f8320; + private final Schema f8330; + private final Schema f8340; + private final Schema f8350; + private final Schema f8360; + private final Schema f8370; + private final Schema f8380; + private final Schema f8390; + private final Schema f8400; + private final Schema f8410; + private final Schema f8420; + private final Schema f8430; + private final Schema f8440; + private final Schema f8450; + private final Schema f8460; + private final Schema f8470; + private final Schema f8480; + private final Schema f8490; + private final Schema f8500; + private final Schema f8510; + private final Schema f8520; + private final Schema f8530; + private final Schema f8540; + private final Schema f8550; + private final Schema f8560; + private final Schema f8570; + private final Schema f8580; + private final Schema f8590; + private final Schema f8600; + private final Schema f8610; + private final Schema f8620; + private final Schema f8630; + private final Schema f8640; + private final Schema f8650; + private final Schema f8660; + private final Schema f8670; + private final Schema f8680; + private final Schema f8690; + private final Schema f8700; + private final Schema f8710; + private final Schema f8720; + private final Schema f8730; + private final Schema f8740; + private final Schema f8750; + private final Schema f8760; + private final Schema f8770; + private final Schema f8780; + private final Schema f8790; + private final Schema f8800; + private final Schema f8810; + private final Schema f8820; + private final Schema f8830; + private final Schema f8840; + private final Schema f8850; + private final Schema f8860; + private final Schema f8870; + private final Schema f8880; + private final Schema f8890; + private final Schema f8900; + private final Schema f8910; + private final Schema f8920; + private final Schema f8930; + private final Schema f8940; + private final Schema f8950; + private final Schema f8960; + private final Schema f8970; + private final Schema f8980; + private final Schema f8990; + private final Schema f9000; + private final Schema f9010; + private final Schema f9020; + private final Schema f9030; + private final Schema f9040; + private final Schema f9050; + private final Schema f9060; + private final Schema f9070; + private final Schema f9080; + private final Schema f9090; + private final Schema f9100; + private final Schema f9110; + private final Schema f9120; + private final Schema f9130; + private final Schema f9140; + private final Schema f9150; + private final Schema f9160; + private final Schema f9170; + private final Schema f9180; + private final Schema f9190; + private final Schema f9200; + private final Schema f9210; + private final Schema f9220; + private final Schema f9230; + private final Schema f9240; + private final Schema f9250; + private final Schema f9260; + private final Schema f9270; + private final Schema f9280; + private final Schema f9290; + private final Schema f9300; + private final Schema f9310; + private final Schema f9320; + private final Schema f9330; + private final Schema f9340; + private final Schema f9350; + private final Schema f9360; + private final Schema f9370; + private final Schema f9380; + private final Schema f9390; + private final Schema f9400; + private final Schema f9410; + private final Schema f9420; + private final Schema f9430; + private final Schema f9440; + private final Schema f9450; + private final Schema f9460; + private final Schema f9470; + private final Schema f9480; + private final Schema f9490; + private final Schema f9500; + private final Schema f9510; + private final Schema f9520; + private final Schema f9530; + private final Schema f9540; + private final Schema f9550; + private final Schema f9560; + private final Schema f9570; + private final Schema f9580; + private final Schema f9590; + private final Schema f9600; + private final Schema f9610; + private final Schema f9620; + private final Schema f9630; + private final Schema f9640; + private final Schema f9650; + private final Schema f9660; + private final Schema f9670; + private final Schema f9680; + private final Schema f9690; + private final Schema f9700; + private final Schema f9710; + private final Schema f9720; + private final Schema f9730; + private final Schema f9740; + private final Schema f9750; + private final Schema f9760; + private final Schema f9770; + private final Schema f9780; + private final Schema f9790; + private final Schema f9800; + private final Schema f9810; + private final Schema f9820; + private final Schema f9830; + private final Schema f9840; + private final Schema f9850; + private final Schema f9860; + private final Schema f9870; + private final Schema f9880; + private final Schema f9890; + private final Schema f9900; + private final Schema f9910; + private final Schema f9920; + private final Schema f9930; + private final Schema f9940; + private final Schema f9950; + private final Schema f9960; + private final Schema f9970; + private final Schema f9980; + private final Schema f9990; + + public FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema_GenericDeserializer_836892732_836892732(Schema readerSchema) { + this.readerSchema = readerSchema; + this.f00 = readerSchema.getField("F0").schema(); + this.f10 = readerSchema.getField("F1").schema(); + this.f20 = readerSchema.getField("F2").schema(); + this.f30 = readerSchema.getField("F3").schema(); + this.f40 = readerSchema.getField("F4").schema(); + this.f50 = readerSchema.getField("F5").schema(); + this.f60 = readerSchema.getField("F6").schema(); + this.f70 = readerSchema.getField("F7").schema(); + this.f80 = readerSchema.getField("F8").schema(); + this.f90 = readerSchema.getField("F9").schema(); + this.f100 = readerSchema.getField("F10").schema(); + this.f110 = readerSchema.getField("F11").schema(); + this.f120 = readerSchema.getField("F12").schema(); + this.f130 = readerSchema.getField("F13").schema(); + this.f140 = readerSchema.getField("F14").schema(); + this.f150 = readerSchema.getField("F15").schema(); + this.f160 = readerSchema.getField("F16").schema(); + this.f170 = readerSchema.getField("F17").schema(); + this.f180 = readerSchema.getField("F18").schema(); + this.f190 = readerSchema.getField("F19").schema(); + this.f200 = readerSchema.getField("F20").schema(); + this.f210 = readerSchema.getField("F21").schema(); + this.f220 = readerSchema.getField("F22").schema(); + this.f230 = readerSchema.getField("F23").schema(); + this.f240 = readerSchema.getField("F24").schema(); + this.f250 = readerSchema.getField("F25").schema(); + this.f260 = readerSchema.getField("F26").schema(); + this.f270 = readerSchema.getField("F27").schema(); + this.f280 = readerSchema.getField("F28").schema(); + this.f290 = readerSchema.getField("F29").schema(); + this.f300 = readerSchema.getField("F30").schema(); + this.f310 = readerSchema.getField("F31").schema(); + this.f320 = readerSchema.getField("F32").schema(); + this.f330 = readerSchema.getField("F33").schema(); + this.f340 = readerSchema.getField("F34").schema(); + this.f350 = readerSchema.getField("F35").schema(); + this.f360 = readerSchema.getField("F36").schema(); + this.f370 = readerSchema.getField("F37").schema(); + this.f380 = readerSchema.getField("F38").schema(); + this.f390 = readerSchema.getField("F39").schema(); + this.f400 = readerSchema.getField("F40").schema(); + this.f410 = readerSchema.getField("F41").schema(); + this.f420 = readerSchema.getField("F42").schema(); + this.f430 = readerSchema.getField("F43").schema(); + this.f440 = readerSchema.getField("F44").schema(); + this.f450 = readerSchema.getField("F45").schema(); + this.f460 = readerSchema.getField("F46").schema(); + this.f470 = readerSchema.getField("F47").schema(); + this.f480 = readerSchema.getField("F48").schema(); + this.f490 = readerSchema.getField("F49").schema(); + this.f500 = readerSchema.getField("F50").schema(); + this.f510 = readerSchema.getField("F51").schema(); + this.f520 = readerSchema.getField("F52").schema(); + this.f530 = readerSchema.getField("F53").schema(); + this.f540 = readerSchema.getField("F54").schema(); + this.f550 = readerSchema.getField("F55").schema(); + this.f560 = readerSchema.getField("F56").schema(); + this.f570 = readerSchema.getField("F57").schema(); + this.f580 = readerSchema.getField("F58").schema(); + this.f590 = readerSchema.getField("F59").schema(); + this.f600 = readerSchema.getField("F60").schema(); + this.f610 = readerSchema.getField("F61").schema(); + this.f620 = readerSchema.getField("F62").schema(); + this.f630 = readerSchema.getField("F63").schema(); + this.f640 = readerSchema.getField("F64").schema(); + this.f650 = readerSchema.getField("F65").schema(); + this.f660 = readerSchema.getField("F66").schema(); + this.f670 = readerSchema.getField("F67").schema(); + this.f680 = readerSchema.getField("F68").schema(); + this.f690 = readerSchema.getField("F69").schema(); + this.f700 = readerSchema.getField("F70").schema(); + this.f710 = readerSchema.getField("F71").schema(); + this.f720 = readerSchema.getField("F72").schema(); + this.f730 = readerSchema.getField("F73").schema(); + this.f740 = readerSchema.getField("F74").schema(); + this.f750 = readerSchema.getField("F75").schema(); + this.f760 = readerSchema.getField("F76").schema(); + this.f770 = readerSchema.getField("F77").schema(); + this.f780 = readerSchema.getField("F78").schema(); + this.f790 = readerSchema.getField("F79").schema(); + this.f800 = readerSchema.getField("F80").schema(); + this.f810 = readerSchema.getField("F81").schema(); + this.f820 = readerSchema.getField("F82").schema(); + this.f830 = readerSchema.getField("F83").schema(); + this.f840 = readerSchema.getField("F84").schema(); + this.f850 = readerSchema.getField("F85").schema(); + this.f860 = readerSchema.getField("F86").schema(); + this.f870 = readerSchema.getField("F87").schema(); + this.f880 = readerSchema.getField("F88").schema(); + this.f890 = readerSchema.getField("F89").schema(); + this.f900 = readerSchema.getField("F90").schema(); + this.f910 = readerSchema.getField("F91").schema(); + this.f920 = readerSchema.getField("F92").schema(); + this.f930 = readerSchema.getField("F93").schema(); + this.f940 = readerSchema.getField("F94").schema(); + this.f950 = readerSchema.getField("F95").schema(); + this.f960 = readerSchema.getField("F96").schema(); + this.f970 = readerSchema.getField("F97").schema(); + this.f980 = readerSchema.getField("F98").schema(); + this.f990 = readerSchema.getField("F99").schema(); + this.f1000 = readerSchema.getField("F100").schema(); + this.f1010 = readerSchema.getField("F101").schema(); + this.f1020 = readerSchema.getField("F102").schema(); + this.f1030 = readerSchema.getField("F103").schema(); + this.f1040 = readerSchema.getField("F104").schema(); + this.f1050 = readerSchema.getField("F105").schema(); + this.f1060 = readerSchema.getField("F106").schema(); + this.f1070 = readerSchema.getField("F107").schema(); + this.f1080 = readerSchema.getField("F108").schema(); + this.f1090 = readerSchema.getField("F109").schema(); + this.f1100 = readerSchema.getField("F110").schema(); + this.f1110 = readerSchema.getField("F111").schema(); + this.f1120 = readerSchema.getField("F112").schema(); + this.f1130 = readerSchema.getField("F113").schema(); + this.f1140 = readerSchema.getField("F114").schema(); + this.f1150 = readerSchema.getField("F115").schema(); + this.f1160 = readerSchema.getField("F116").schema(); + this.f1170 = readerSchema.getField("F117").schema(); + this.f1180 = readerSchema.getField("F118").schema(); + this.f1190 = readerSchema.getField("F119").schema(); + this.f1200 = readerSchema.getField("F120").schema(); + this.f1210 = readerSchema.getField("F121").schema(); + this.f1220 = readerSchema.getField("F122").schema(); + this.f1230 = readerSchema.getField("F123").schema(); + this.f1240 = readerSchema.getField("F124").schema(); + this.f1250 = readerSchema.getField("F125").schema(); + this.f1260 = readerSchema.getField("F126").schema(); + this.f1270 = readerSchema.getField("F127").schema(); + this.f1280 = readerSchema.getField("F128").schema(); + this.f1290 = readerSchema.getField("F129").schema(); + this.f1300 = readerSchema.getField("F130").schema(); + this.f1310 = readerSchema.getField("F131").schema(); + this.f1320 = readerSchema.getField("F132").schema(); + this.f1330 = readerSchema.getField("F133").schema(); + this.f1340 = readerSchema.getField("F134").schema(); + this.f1350 = readerSchema.getField("F135").schema(); + this.f1360 = readerSchema.getField("F136").schema(); + this.f1370 = readerSchema.getField("F137").schema(); + this.f1380 = readerSchema.getField("F138").schema(); + this.f1390 = readerSchema.getField("F139").schema(); + this.f1400 = readerSchema.getField("F140").schema(); + this.f1410 = readerSchema.getField("F141").schema(); + this.f1420 = readerSchema.getField("F142").schema(); + this.f1430 = readerSchema.getField("F143").schema(); + this.f1440 = readerSchema.getField("F144").schema(); + this.f1450 = readerSchema.getField("F145").schema(); + this.f1460 = readerSchema.getField("F146").schema(); + this.f1470 = readerSchema.getField("F147").schema(); + this.f1480 = readerSchema.getField("F148").schema(); + this.f1490 = readerSchema.getField("F149").schema(); + this.f1500 = readerSchema.getField("F150").schema(); + this.f1510 = readerSchema.getField("F151").schema(); + this.f1520 = readerSchema.getField("F152").schema(); + this.f1530 = readerSchema.getField("F153").schema(); + this.f1540 = readerSchema.getField("F154").schema(); + this.f1550 = readerSchema.getField("F155").schema(); + this.f1560 = readerSchema.getField("F156").schema(); + this.f1570 = readerSchema.getField("F157").schema(); + this.f1580 = readerSchema.getField("F158").schema(); + this.f1590 = readerSchema.getField("F159").schema(); + this.f1600 = readerSchema.getField("F160").schema(); + this.f1610 = readerSchema.getField("F161").schema(); + this.f1620 = readerSchema.getField("F162").schema(); + this.f1630 = readerSchema.getField("F163").schema(); + this.f1640 = readerSchema.getField("F164").schema(); + this.f1650 = readerSchema.getField("F165").schema(); + this.f1660 = readerSchema.getField("F166").schema(); + this.f1670 = readerSchema.getField("F167").schema(); + this.f1680 = readerSchema.getField("F168").schema(); + this.f1690 = readerSchema.getField("F169").schema(); + this.f1700 = readerSchema.getField("F170").schema(); + this.f1710 = readerSchema.getField("F171").schema(); + this.f1720 = readerSchema.getField("F172").schema(); + this.f1730 = readerSchema.getField("F173").schema(); + this.f1740 = readerSchema.getField("F174").schema(); + this.f1750 = readerSchema.getField("F175").schema(); + this.f1760 = readerSchema.getField("F176").schema(); + this.f1770 = readerSchema.getField("F177").schema(); + this.f1780 = readerSchema.getField("F178").schema(); + this.f1790 = readerSchema.getField("F179").schema(); + this.f1800 = readerSchema.getField("F180").schema(); + this.f1810 = readerSchema.getField("F181").schema(); + this.f1820 = readerSchema.getField("F182").schema(); + this.f1830 = readerSchema.getField("F183").schema(); + this.f1840 = readerSchema.getField("F184").schema(); + this.f1850 = readerSchema.getField("F185").schema(); + this.f1860 = readerSchema.getField("F186").schema(); + this.f1870 = readerSchema.getField("F187").schema(); + this.f1880 = readerSchema.getField("F188").schema(); + this.f1890 = readerSchema.getField("F189").schema(); + this.f1900 = readerSchema.getField("F190").schema(); + this.f1910 = readerSchema.getField("F191").schema(); + this.f1920 = readerSchema.getField("F192").schema(); + this.f1930 = readerSchema.getField("F193").schema(); + this.f1940 = readerSchema.getField("F194").schema(); + this.f1950 = readerSchema.getField("F195").schema(); + this.f1960 = readerSchema.getField("F196").schema(); + this.f1970 = readerSchema.getField("F197").schema(); + this.f1980 = readerSchema.getField("F198").schema(); + this.f1990 = readerSchema.getField("F199").schema(); + this.f2000 = readerSchema.getField("F200").schema(); + this.f2010 = readerSchema.getField("F201").schema(); + this.f2020 = readerSchema.getField("F202").schema(); + this.f2030 = readerSchema.getField("F203").schema(); + this.f2040 = readerSchema.getField("F204").schema(); + this.f2050 = readerSchema.getField("F205").schema(); + this.f2060 = readerSchema.getField("F206").schema(); + this.f2070 = readerSchema.getField("F207").schema(); + this.f2080 = readerSchema.getField("F208").schema(); + this.f2090 = readerSchema.getField("F209").schema(); + this.f2100 = readerSchema.getField("F210").schema(); + this.f2110 = readerSchema.getField("F211").schema(); + this.f2120 = readerSchema.getField("F212").schema(); + this.f2130 = readerSchema.getField("F213").schema(); + this.f2140 = readerSchema.getField("F214").schema(); + this.f2150 = readerSchema.getField("F215").schema(); + this.f2160 = readerSchema.getField("F216").schema(); + this.f2170 = readerSchema.getField("F217").schema(); + this.f2180 = readerSchema.getField("F218").schema(); + this.f2190 = readerSchema.getField("F219").schema(); + this.f2200 = readerSchema.getField("F220").schema(); + this.f2210 = readerSchema.getField("F221").schema(); + this.f2220 = readerSchema.getField("F222").schema(); + this.f2230 = readerSchema.getField("F223").schema(); + this.f2240 = readerSchema.getField("F224").schema(); + this.f2250 = readerSchema.getField("F225").schema(); + this.f2260 = readerSchema.getField("F226").schema(); + this.f2270 = readerSchema.getField("F227").schema(); + this.f2280 = readerSchema.getField("F228").schema(); + this.f2290 = readerSchema.getField("F229").schema(); + this.f2300 = readerSchema.getField("F230").schema(); + this.f2310 = readerSchema.getField("F231").schema(); + this.f2320 = readerSchema.getField("F232").schema(); + this.f2330 = readerSchema.getField("F233").schema(); + this.f2340 = readerSchema.getField("F234").schema(); + this.f2350 = readerSchema.getField("F235").schema(); + this.f2360 = readerSchema.getField("F236").schema(); + this.f2370 = readerSchema.getField("F237").schema(); + this.f2380 = readerSchema.getField("F238").schema(); + this.f2390 = readerSchema.getField("F239").schema(); + this.f2400 = readerSchema.getField("F240").schema(); + this.f2410 = readerSchema.getField("F241").schema(); + this.f2420 = readerSchema.getField("F242").schema(); + this.f2430 = readerSchema.getField("F243").schema(); + this.f2440 = readerSchema.getField("F244").schema(); + this.f2450 = readerSchema.getField("F245").schema(); + this.f2460 = readerSchema.getField("F246").schema(); + this.f2470 = readerSchema.getField("F247").schema(); + this.f2480 = readerSchema.getField("F248").schema(); + this.f2490 = readerSchema.getField("F249").schema(); + this.f2500 = readerSchema.getField("F250").schema(); + this.f2510 = readerSchema.getField("F251").schema(); + this.f2520 = readerSchema.getField("F252").schema(); + this.f2530 = readerSchema.getField("F253").schema(); + this.f2540 = readerSchema.getField("F254").schema(); + this.f2550 = readerSchema.getField("F255").schema(); + this.f2560 = readerSchema.getField("F256").schema(); + this.f2570 = readerSchema.getField("F257").schema(); + this.f2580 = readerSchema.getField("F258").schema(); + this.f2590 = readerSchema.getField("F259").schema(); + this.f2600 = readerSchema.getField("F260").schema(); + this.f2610 = readerSchema.getField("F261").schema(); + this.f2620 = readerSchema.getField("F262").schema(); + this.f2630 = readerSchema.getField("F263").schema(); + this.f2640 = readerSchema.getField("F264").schema(); + this.f2650 = readerSchema.getField("F265").schema(); + this.f2660 = readerSchema.getField("F266").schema(); + this.f2670 = readerSchema.getField("F267").schema(); + this.f2680 = readerSchema.getField("F268").schema(); + this.f2690 = readerSchema.getField("F269").schema(); + this.f2700 = readerSchema.getField("F270").schema(); + this.f2710 = readerSchema.getField("F271").schema(); + this.f2720 = readerSchema.getField("F272").schema(); + this.f2730 = readerSchema.getField("F273").schema(); + this.f2740 = readerSchema.getField("F274").schema(); + this.f2750 = readerSchema.getField("F275").schema(); + this.f2760 = readerSchema.getField("F276").schema(); + this.f2770 = readerSchema.getField("F277").schema(); + this.f2780 = readerSchema.getField("F278").schema(); + this.f2790 = readerSchema.getField("F279").schema(); + this.f2800 = readerSchema.getField("F280").schema(); + this.f2810 = readerSchema.getField("F281").schema(); + this.f2820 = readerSchema.getField("F282").schema(); + this.f2830 = readerSchema.getField("F283").schema(); + this.f2840 = readerSchema.getField("F284").schema(); + this.f2850 = readerSchema.getField("F285").schema(); + this.f2860 = readerSchema.getField("F286").schema(); + this.f2870 = readerSchema.getField("F287").schema(); + this.f2880 = readerSchema.getField("F288").schema(); + this.f2890 = readerSchema.getField("F289").schema(); + this.f2900 = readerSchema.getField("F290").schema(); + this.f2910 = readerSchema.getField("F291").schema(); + this.f2920 = readerSchema.getField("F292").schema(); + this.f2930 = readerSchema.getField("F293").schema(); + this.f2940 = readerSchema.getField("F294").schema(); + this.f2950 = readerSchema.getField("F295").schema(); + this.f2960 = readerSchema.getField("F296").schema(); + this.f2970 = readerSchema.getField("F297").schema(); + this.f2980 = readerSchema.getField("F298").schema(); + this.f2990 = readerSchema.getField("F299").schema(); + this.f3000 = readerSchema.getField("F300").schema(); + this.f3010 = readerSchema.getField("F301").schema(); + this.f3020 = readerSchema.getField("F302").schema(); + this.f3030 = readerSchema.getField("F303").schema(); + this.f3040 = readerSchema.getField("F304").schema(); + this.f3050 = readerSchema.getField("F305").schema(); + this.f3060 = readerSchema.getField("F306").schema(); + this.f3070 = readerSchema.getField("F307").schema(); + this.f3080 = readerSchema.getField("F308").schema(); + this.f3090 = readerSchema.getField("F309").schema(); + this.f3100 = readerSchema.getField("F310").schema(); + this.f3110 = readerSchema.getField("F311").schema(); + this.f3120 = readerSchema.getField("F312").schema(); + this.f3130 = readerSchema.getField("F313").schema(); + this.f3140 = readerSchema.getField("F314").schema(); + this.f3150 = readerSchema.getField("F315").schema(); + this.f3160 = readerSchema.getField("F316").schema(); + this.f3170 = readerSchema.getField("F317").schema(); + this.f3180 = readerSchema.getField("F318").schema(); + this.f3190 = readerSchema.getField("F319").schema(); + this.f3200 = readerSchema.getField("F320").schema(); + this.f3210 = readerSchema.getField("F321").schema(); + this.f3220 = readerSchema.getField("F322").schema(); + this.f3230 = readerSchema.getField("F323").schema(); + this.f3240 = readerSchema.getField("F324").schema(); + this.f3250 = readerSchema.getField("F325").schema(); + this.f3260 = readerSchema.getField("F326").schema(); + this.f3270 = readerSchema.getField("F327").schema(); + this.f3280 = readerSchema.getField("F328").schema(); + this.f3290 = readerSchema.getField("F329").schema(); + this.f3300 = readerSchema.getField("F330").schema(); + this.f3310 = readerSchema.getField("F331").schema(); + this.f3320 = readerSchema.getField("F332").schema(); + this.f3330 = readerSchema.getField("F333").schema(); + this.f3340 = readerSchema.getField("F334").schema(); + this.f3350 = readerSchema.getField("F335").schema(); + this.f3360 = readerSchema.getField("F336").schema(); + this.f3370 = readerSchema.getField("F337").schema(); + this.f3380 = readerSchema.getField("F338").schema(); + this.f3390 = readerSchema.getField("F339").schema(); + this.f3400 = readerSchema.getField("F340").schema(); + this.f3410 = readerSchema.getField("F341").schema(); + this.f3420 = readerSchema.getField("F342").schema(); + this.f3430 = readerSchema.getField("F343").schema(); + this.f3440 = readerSchema.getField("F344").schema(); + this.f3450 = readerSchema.getField("F345").schema(); + this.f3460 = readerSchema.getField("F346").schema(); + this.f3470 = readerSchema.getField("F347").schema(); + this.f3480 = readerSchema.getField("F348").schema(); + this.f3490 = readerSchema.getField("F349").schema(); + this.f3500 = readerSchema.getField("F350").schema(); + this.f3510 = readerSchema.getField("F351").schema(); + this.f3520 = readerSchema.getField("F352").schema(); + this.f3530 = readerSchema.getField("F353").schema(); + this.f3540 = readerSchema.getField("F354").schema(); + this.f3550 = readerSchema.getField("F355").schema(); + this.f3560 = readerSchema.getField("F356").schema(); + this.f3570 = readerSchema.getField("F357").schema(); + this.f3580 = readerSchema.getField("F358").schema(); + this.f3590 = readerSchema.getField("F359").schema(); + this.f3600 = readerSchema.getField("F360").schema(); + this.f3610 = readerSchema.getField("F361").schema(); + this.f3620 = readerSchema.getField("F362").schema(); + this.f3630 = readerSchema.getField("F363").schema(); + this.f3640 = readerSchema.getField("F364").schema(); + this.f3650 = readerSchema.getField("F365").schema(); + this.f3660 = readerSchema.getField("F366").schema(); + this.f3670 = readerSchema.getField("F367").schema(); + this.f3680 = readerSchema.getField("F368").schema(); + this.f3690 = readerSchema.getField("F369").schema(); + this.f3700 = readerSchema.getField("F370").schema(); + this.f3710 = readerSchema.getField("F371").schema(); + this.f3720 = readerSchema.getField("F372").schema(); + this.f3730 = readerSchema.getField("F373").schema(); + this.f3740 = readerSchema.getField("F374").schema(); + this.f3750 = readerSchema.getField("F375").schema(); + this.f3760 = readerSchema.getField("F376").schema(); + this.f3770 = readerSchema.getField("F377").schema(); + this.f3780 = readerSchema.getField("F378").schema(); + this.f3790 = readerSchema.getField("F379").schema(); + this.f3800 = readerSchema.getField("F380").schema(); + this.f3810 = readerSchema.getField("F381").schema(); + this.f3820 = readerSchema.getField("F382").schema(); + this.f3830 = readerSchema.getField("F383").schema(); + this.f3840 = readerSchema.getField("F384").schema(); + this.f3850 = readerSchema.getField("F385").schema(); + this.f3860 = readerSchema.getField("F386").schema(); + this.f3870 = readerSchema.getField("F387").schema(); + this.f3880 = readerSchema.getField("F388").schema(); + this.f3890 = readerSchema.getField("F389").schema(); + this.f3900 = readerSchema.getField("F390").schema(); + this.f3910 = readerSchema.getField("F391").schema(); + this.f3920 = readerSchema.getField("F392").schema(); + this.f3930 = readerSchema.getField("F393").schema(); + this.f3940 = readerSchema.getField("F394").schema(); + this.f3950 = readerSchema.getField("F395").schema(); + this.f3960 = readerSchema.getField("F396").schema(); + this.f3970 = readerSchema.getField("F397").schema(); + this.f3980 = readerSchema.getField("F398").schema(); + this.f3990 = readerSchema.getField("F399").schema(); + this.f4000 = readerSchema.getField("F400").schema(); + this.f4010 = readerSchema.getField("F401").schema(); + this.f4020 = readerSchema.getField("F402").schema(); + this.f4030 = readerSchema.getField("F403").schema(); + this.f4040 = readerSchema.getField("F404").schema(); + this.f4050 = readerSchema.getField("F405").schema(); + this.f4060 = readerSchema.getField("F406").schema(); + this.f4070 = readerSchema.getField("F407").schema(); + this.f4080 = readerSchema.getField("F408").schema(); + this.f4090 = readerSchema.getField("F409").schema(); + this.f4100 = readerSchema.getField("F410").schema(); + this.f4110 = readerSchema.getField("F411").schema(); + this.f4120 = readerSchema.getField("F412").schema(); + this.f4130 = readerSchema.getField("F413").schema(); + this.f4140 = readerSchema.getField("F414").schema(); + this.f4150 = readerSchema.getField("F415").schema(); + this.f4160 = readerSchema.getField("F416").schema(); + this.f4170 = readerSchema.getField("F417").schema(); + this.f4180 = readerSchema.getField("F418").schema(); + this.f4190 = readerSchema.getField("F419").schema(); + this.f4200 = readerSchema.getField("F420").schema(); + this.f4210 = readerSchema.getField("F421").schema(); + this.f4220 = readerSchema.getField("F422").schema(); + this.f4230 = readerSchema.getField("F423").schema(); + this.f4240 = readerSchema.getField("F424").schema(); + this.f4250 = readerSchema.getField("F425").schema(); + this.f4260 = readerSchema.getField("F426").schema(); + this.f4270 = readerSchema.getField("F427").schema(); + this.f4280 = readerSchema.getField("F428").schema(); + this.f4290 = readerSchema.getField("F429").schema(); + this.f4300 = readerSchema.getField("F430").schema(); + this.f4310 = readerSchema.getField("F431").schema(); + this.f4320 = readerSchema.getField("F432").schema(); + this.f4330 = readerSchema.getField("F433").schema(); + this.f4340 = readerSchema.getField("F434").schema(); + this.f4350 = readerSchema.getField("F435").schema(); + this.f4360 = readerSchema.getField("F436").schema(); + this.f4370 = readerSchema.getField("F437").schema(); + this.f4380 = readerSchema.getField("F438").schema(); + this.f4390 = readerSchema.getField("F439").schema(); + this.f4400 = readerSchema.getField("F440").schema(); + this.f4410 = readerSchema.getField("F441").schema(); + this.f4420 = readerSchema.getField("F442").schema(); + this.f4430 = readerSchema.getField("F443").schema(); + this.f4440 = readerSchema.getField("F444").schema(); + this.f4450 = readerSchema.getField("F445").schema(); + this.f4460 = readerSchema.getField("F446").schema(); + this.f4470 = readerSchema.getField("F447").schema(); + this.f4480 = readerSchema.getField("F448").schema(); + this.f4490 = readerSchema.getField("F449").schema(); + this.f4500 = readerSchema.getField("F450").schema(); + this.f4510 = readerSchema.getField("F451").schema(); + this.f4520 = readerSchema.getField("F452").schema(); + this.f4530 = readerSchema.getField("F453").schema(); + this.f4540 = readerSchema.getField("F454").schema(); + this.f4550 = readerSchema.getField("F455").schema(); + this.f4560 = readerSchema.getField("F456").schema(); + this.f4570 = readerSchema.getField("F457").schema(); + this.f4580 = readerSchema.getField("F458").schema(); + this.f4590 = readerSchema.getField("F459").schema(); + this.f4600 = readerSchema.getField("F460").schema(); + this.f4610 = readerSchema.getField("F461").schema(); + this.f4620 = readerSchema.getField("F462").schema(); + this.f4630 = readerSchema.getField("F463").schema(); + this.f4640 = readerSchema.getField("F464").schema(); + this.f4650 = readerSchema.getField("F465").schema(); + this.f4660 = readerSchema.getField("F466").schema(); + this.f4670 = readerSchema.getField("F467").schema(); + this.f4680 = readerSchema.getField("F468").schema(); + this.f4690 = readerSchema.getField("F469").schema(); + this.f4700 = readerSchema.getField("F470").schema(); + this.f4710 = readerSchema.getField("F471").schema(); + this.f4720 = readerSchema.getField("F472").schema(); + this.f4730 = readerSchema.getField("F473").schema(); + this.f4740 = readerSchema.getField("F474").schema(); + this.f4750 = readerSchema.getField("F475").schema(); + this.f4760 = readerSchema.getField("F476").schema(); + this.f4770 = readerSchema.getField("F477").schema(); + this.f4780 = readerSchema.getField("F478").schema(); + this.f4790 = readerSchema.getField("F479").schema(); + this.f4800 = readerSchema.getField("F480").schema(); + this.f4810 = readerSchema.getField("F481").schema(); + this.f4820 = readerSchema.getField("F482").schema(); + this.f4830 = readerSchema.getField("F483").schema(); + this.f4840 = readerSchema.getField("F484").schema(); + this.f4850 = readerSchema.getField("F485").schema(); + this.f4860 = readerSchema.getField("F486").schema(); + this.f4870 = readerSchema.getField("F487").schema(); + this.f4880 = readerSchema.getField("F488").schema(); + this.f4890 = readerSchema.getField("F489").schema(); + this.f4900 = readerSchema.getField("F490").schema(); + this.f4910 = readerSchema.getField("F491").schema(); + this.f4920 = readerSchema.getField("F492").schema(); + this.f4930 = readerSchema.getField("F493").schema(); + this.f4940 = readerSchema.getField("F494").schema(); + this.f4950 = readerSchema.getField("F495").schema(); + this.f4960 = readerSchema.getField("F496").schema(); + this.f4970 = readerSchema.getField("F497").schema(); + this.f4980 = readerSchema.getField("F498").schema(); + this.f4990 = readerSchema.getField("F499").schema(); + this.f5000 = readerSchema.getField("F500").schema(); + this.f5010 = readerSchema.getField("F501").schema(); + this.f5020 = readerSchema.getField("F502").schema(); + this.f5030 = readerSchema.getField("F503").schema(); + this.f5040 = readerSchema.getField("F504").schema(); + this.f5050 = readerSchema.getField("F505").schema(); + this.f5060 = readerSchema.getField("F506").schema(); + this.f5070 = readerSchema.getField("F507").schema(); + this.f5080 = readerSchema.getField("F508").schema(); + this.f5090 = readerSchema.getField("F509").schema(); + this.f5100 = readerSchema.getField("F510").schema(); + this.f5110 = readerSchema.getField("F511").schema(); + this.f5120 = readerSchema.getField("F512").schema(); + this.f5130 = readerSchema.getField("F513").schema(); + this.f5140 = readerSchema.getField("F514").schema(); + this.f5150 = readerSchema.getField("F515").schema(); + this.f5160 = readerSchema.getField("F516").schema(); + this.f5170 = readerSchema.getField("F517").schema(); + this.f5180 = readerSchema.getField("F518").schema(); + this.f5190 = readerSchema.getField("F519").schema(); + this.f5200 = readerSchema.getField("F520").schema(); + this.f5210 = readerSchema.getField("F521").schema(); + this.f5220 = readerSchema.getField("F522").schema(); + this.f5230 = readerSchema.getField("F523").schema(); + this.f5240 = readerSchema.getField("F524").schema(); + this.f5250 = readerSchema.getField("F525").schema(); + this.f5260 = readerSchema.getField("F526").schema(); + this.f5270 = readerSchema.getField("F527").schema(); + this.f5280 = readerSchema.getField("F528").schema(); + this.f5290 = readerSchema.getField("F529").schema(); + this.f5300 = readerSchema.getField("F530").schema(); + this.f5310 = readerSchema.getField("F531").schema(); + this.f5320 = readerSchema.getField("F532").schema(); + this.f5330 = readerSchema.getField("F533").schema(); + this.f5340 = readerSchema.getField("F534").schema(); + this.f5350 = readerSchema.getField("F535").schema(); + this.f5360 = readerSchema.getField("F536").schema(); + this.f5370 = readerSchema.getField("F537").schema(); + this.f5380 = readerSchema.getField("F538").schema(); + this.f5390 = readerSchema.getField("F539").schema(); + this.f5400 = readerSchema.getField("F540").schema(); + this.f5410 = readerSchema.getField("F541").schema(); + this.f5420 = readerSchema.getField("F542").schema(); + this.f5430 = readerSchema.getField("F543").schema(); + this.f5440 = readerSchema.getField("F544").schema(); + this.f5450 = readerSchema.getField("F545").schema(); + this.f5460 = readerSchema.getField("F546").schema(); + this.f5470 = readerSchema.getField("F547").schema(); + this.f5480 = readerSchema.getField("F548").schema(); + this.f5490 = readerSchema.getField("F549").schema(); + this.f5500 = readerSchema.getField("F550").schema(); + this.f5510 = readerSchema.getField("F551").schema(); + this.f5520 = readerSchema.getField("F552").schema(); + this.f5530 = readerSchema.getField("F553").schema(); + this.f5540 = readerSchema.getField("F554").schema(); + this.f5550 = readerSchema.getField("F555").schema(); + this.f5560 = readerSchema.getField("F556").schema(); + this.f5570 = readerSchema.getField("F557").schema(); + this.f5580 = readerSchema.getField("F558").schema(); + this.f5590 = readerSchema.getField("F559").schema(); + this.f5600 = readerSchema.getField("F560").schema(); + this.f5610 = readerSchema.getField("F561").schema(); + this.f5620 = readerSchema.getField("F562").schema(); + this.f5630 = readerSchema.getField("F563").schema(); + this.f5640 = readerSchema.getField("F564").schema(); + this.f5650 = readerSchema.getField("F565").schema(); + this.f5660 = readerSchema.getField("F566").schema(); + this.f5670 = readerSchema.getField("F567").schema(); + this.f5680 = readerSchema.getField("F568").schema(); + this.f5690 = readerSchema.getField("F569").schema(); + this.f5700 = readerSchema.getField("F570").schema(); + this.f5710 = readerSchema.getField("F571").schema(); + this.f5720 = readerSchema.getField("F572").schema(); + this.f5730 = readerSchema.getField("F573").schema(); + this.f5740 = readerSchema.getField("F574").schema(); + this.f5750 = readerSchema.getField("F575").schema(); + this.f5760 = readerSchema.getField("F576").schema(); + this.f5770 = readerSchema.getField("F577").schema(); + this.f5780 = readerSchema.getField("F578").schema(); + this.f5790 = readerSchema.getField("F579").schema(); + this.f5800 = readerSchema.getField("F580").schema(); + this.f5810 = readerSchema.getField("F581").schema(); + this.f5820 = readerSchema.getField("F582").schema(); + this.f5830 = readerSchema.getField("F583").schema(); + this.f5840 = readerSchema.getField("F584").schema(); + this.f5850 = readerSchema.getField("F585").schema(); + this.f5860 = readerSchema.getField("F586").schema(); + this.f5870 = readerSchema.getField("F587").schema(); + this.f5880 = readerSchema.getField("F588").schema(); + this.f5890 = readerSchema.getField("F589").schema(); + this.f5900 = readerSchema.getField("F590").schema(); + this.f5910 = readerSchema.getField("F591").schema(); + this.f5920 = readerSchema.getField("F592").schema(); + this.f5930 = readerSchema.getField("F593").schema(); + this.f5940 = readerSchema.getField("F594").schema(); + this.f5950 = readerSchema.getField("F595").schema(); + this.f5960 = readerSchema.getField("F596").schema(); + this.f5970 = readerSchema.getField("F597").schema(); + this.f5980 = readerSchema.getField("F598").schema(); + this.f5990 = readerSchema.getField("F599").schema(); + this.f6000 = readerSchema.getField("F600").schema(); + this.f6010 = readerSchema.getField("F601").schema(); + this.f6020 = readerSchema.getField("F602").schema(); + this.f6030 = readerSchema.getField("F603").schema(); + this.f6040 = readerSchema.getField("F604").schema(); + this.f6050 = readerSchema.getField("F605").schema(); + this.f6060 = readerSchema.getField("F606").schema(); + this.f6070 = readerSchema.getField("F607").schema(); + this.f6080 = readerSchema.getField("F608").schema(); + this.f6090 = readerSchema.getField("F609").schema(); + this.f6100 = readerSchema.getField("F610").schema(); + this.f6110 = readerSchema.getField("F611").schema(); + this.f6120 = readerSchema.getField("F612").schema(); + this.f6130 = readerSchema.getField("F613").schema(); + this.f6140 = readerSchema.getField("F614").schema(); + this.f6150 = readerSchema.getField("F615").schema(); + this.f6160 = readerSchema.getField("F616").schema(); + this.f6170 = readerSchema.getField("F617").schema(); + this.f6180 = readerSchema.getField("F618").schema(); + this.f6190 = readerSchema.getField("F619").schema(); + this.f6200 = readerSchema.getField("F620").schema(); + this.f6210 = readerSchema.getField("F621").schema(); + this.f6220 = readerSchema.getField("F622").schema(); + this.f6230 = readerSchema.getField("F623").schema(); + this.f6240 = readerSchema.getField("F624").schema(); + this.f6250 = readerSchema.getField("F625").schema(); + this.f6260 = readerSchema.getField("F626").schema(); + this.f6270 = readerSchema.getField("F627").schema(); + this.f6280 = readerSchema.getField("F628").schema(); + this.f6290 = readerSchema.getField("F629").schema(); + this.f6300 = readerSchema.getField("F630").schema(); + this.f6310 = readerSchema.getField("F631").schema(); + this.f6320 = readerSchema.getField("F632").schema(); + this.f6330 = readerSchema.getField("F633").schema(); + this.f6340 = readerSchema.getField("F634").schema(); + this.f6350 = readerSchema.getField("F635").schema(); + this.f6360 = readerSchema.getField("F636").schema(); + this.f6370 = readerSchema.getField("F637").schema(); + this.f6380 = readerSchema.getField("F638").schema(); + this.f6390 = readerSchema.getField("F639").schema(); + this.f6400 = readerSchema.getField("F640").schema(); + this.f6410 = readerSchema.getField("F641").schema(); + this.f6420 = readerSchema.getField("F642").schema(); + this.f6430 = readerSchema.getField("F643").schema(); + this.f6440 = readerSchema.getField("F644").schema(); + this.f6450 = readerSchema.getField("F645").schema(); + this.f6460 = readerSchema.getField("F646").schema(); + this.f6470 = readerSchema.getField("F647").schema(); + this.f6480 = readerSchema.getField("F648").schema(); + this.f6490 = readerSchema.getField("F649").schema(); + this.f6500 = readerSchema.getField("F650").schema(); + this.f6510 = readerSchema.getField("F651").schema(); + this.f6520 = readerSchema.getField("F652").schema(); + this.f6530 = readerSchema.getField("F653").schema(); + this.f6540 = readerSchema.getField("F654").schema(); + this.f6550 = readerSchema.getField("F655").schema(); + this.f6560 = readerSchema.getField("F656").schema(); + this.f6570 = readerSchema.getField("F657").schema(); + this.f6580 = readerSchema.getField("F658").schema(); + this.f6590 = readerSchema.getField("F659").schema(); + this.f6600 = readerSchema.getField("F660").schema(); + this.f6610 = readerSchema.getField("F661").schema(); + this.f6620 = readerSchema.getField("F662").schema(); + this.f6630 = readerSchema.getField("F663").schema(); + this.f6640 = readerSchema.getField("F664").schema(); + this.f6650 = readerSchema.getField("F665").schema(); + this.f6660 = readerSchema.getField("F666").schema(); + this.f6670 = readerSchema.getField("F667").schema(); + this.f6680 = readerSchema.getField("F668").schema(); + this.f6690 = readerSchema.getField("F669").schema(); + this.f6700 = readerSchema.getField("F670").schema(); + this.f6710 = readerSchema.getField("F671").schema(); + this.f6720 = readerSchema.getField("F672").schema(); + this.f6730 = readerSchema.getField("F673").schema(); + this.f6740 = readerSchema.getField("F674").schema(); + this.f6750 = readerSchema.getField("F675").schema(); + this.f6760 = readerSchema.getField("F676").schema(); + this.f6770 = readerSchema.getField("F677").schema(); + this.f6780 = readerSchema.getField("F678").schema(); + this.f6790 = readerSchema.getField("F679").schema(); + this.f6800 = readerSchema.getField("F680").schema(); + this.f6810 = readerSchema.getField("F681").schema(); + this.f6820 = readerSchema.getField("F682").schema(); + this.f6830 = readerSchema.getField("F683").schema(); + this.f6840 = readerSchema.getField("F684").schema(); + this.f6850 = readerSchema.getField("F685").schema(); + this.f6860 = readerSchema.getField("F686").schema(); + this.f6870 = readerSchema.getField("F687").schema(); + this.f6880 = readerSchema.getField("F688").schema(); + this.f6890 = readerSchema.getField("F689").schema(); + this.f6900 = readerSchema.getField("F690").schema(); + this.f6910 = readerSchema.getField("F691").schema(); + this.f6920 = readerSchema.getField("F692").schema(); + this.f6930 = readerSchema.getField("F693").schema(); + this.f6940 = readerSchema.getField("F694").schema(); + this.f6950 = readerSchema.getField("F695").schema(); + this.f6960 = readerSchema.getField("F696").schema(); + this.f6970 = readerSchema.getField("F697").schema(); + this.f6980 = readerSchema.getField("F698").schema(); + this.f6990 = readerSchema.getField("F699").schema(); + this.f7000 = readerSchema.getField("F700").schema(); + this.f7010 = readerSchema.getField("F701").schema(); + this.f7020 = readerSchema.getField("F702").schema(); + this.f7030 = readerSchema.getField("F703").schema(); + this.f7040 = readerSchema.getField("F704").schema(); + this.f7050 = readerSchema.getField("F705").schema(); + this.f7060 = readerSchema.getField("F706").schema(); + this.f7070 = readerSchema.getField("F707").schema(); + this.f7080 = readerSchema.getField("F708").schema(); + this.f7090 = readerSchema.getField("F709").schema(); + this.f7100 = readerSchema.getField("F710").schema(); + this.f7110 = readerSchema.getField("F711").schema(); + this.f7120 = readerSchema.getField("F712").schema(); + this.f7130 = readerSchema.getField("F713").schema(); + this.f7140 = readerSchema.getField("F714").schema(); + this.f7150 = readerSchema.getField("F715").schema(); + this.f7160 = readerSchema.getField("F716").schema(); + this.f7170 = readerSchema.getField("F717").schema(); + this.f7180 = readerSchema.getField("F718").schema(); + this.f7190 = readerSchema.getField("F719").schema(); + this.f7200 = readerSchema.getField("F720").schema(); + this.f7210 = readerSchema.getField("F721").schema(); + this.f7220 = readerSchema.getField("F722").schema(); + this.f7230 = readerSchema.getField("F723").schema(); + this.f7240 = readerSchema.getField("F724").schema(); + this.f7250 = readerSchema.getField("F725").schema(); + this.f7260 = readerSchema.getField("F726").schema(); + this.f7270 = readerSchema.getField("F727").schema(); + this.f7280 = readerSchema.getField("F728").schema(); + this.f7290 = readerSchema.getField("F729").schema(); + this.f7300 = readerSchema.getField("F730").schema(); + this.f7310 = readerSchema.getField("F731").schema(); + this.f7320 = readerSchema.getField("F732").schema(); + this.f7330 = readerSchema.getField("F733").schema(); + this.f7340 = readerSchema.getField("F734").schema(); + this.f7350 = readerSchema.getField("F735").schema(); + this.f7360 = readerSchema.getField("F736").schema(); + this.f7370 = readerSchema.getField("F737").schema(); + this.f7380 = readerSchema.getField("F738").schema(); + this.f7390 = readerSchema.getField("F739").schema(); + this.f7400 = readerSchema.getField("F740").schema(); + this.f7410 = readerSchema.getField("F741").schema(); + this.f7420 = readerSchema.getField("F742").schema(); + this.f7430 = readerSchema.getField("F743").schema(); + this.f7440 = readerSchema.getField("F744").schema(); + this.f7450 = readerSchema.getField("F745").schema(); + this.f7460 = readerSchema.getField("F746").schema(); + this.f7470 = readerSchema.getField("F747").schema(); + this.f7480 = readerSchema.getField("F748").schema(); + this.f7490 = readerSchema.getField("F749").schema(); + this.f7500 = readerSchema.getField("F750").schema(); + this.f7510 = readerSchema.getField("F751").schema(); + this.f7520 = readerSchema.getField("F752").schema(); + this.f7530 = readerSchema.getField("F753").schema(); + this.f7540 = readerSchema.getField("F754").schema(); + this.f7550 = readerSchema.getField("F755").schema(); + this.f7560 = readerSchema.getField("F756").schema(); + this.f7570 = readerSchema.getField("F757").schema(); + this.f7580 = readerSchema.getField("F758").schema(); + this.f7590 = readerSchema.getField("F759").schema(); + this.f7600 = readerSchema.getField("F760").schema(); + this.f7610 = readerSchema.getField("F761").schema(); + this.f7620 = readerSchema.getField("F762").schema(); + this.f7630 = readerSchema.getField("F763").schema(); + this.f7640 = readerSchema.getField("F764").schema(); + this.f7650 = readerSchema.getField("F765").schema(); + this.f7660 = readerSchema.getField("F766").schema(); + this.f7670 = readerSchema.getField("F767").schema(); + this.f7680 = readerSchema.getField("F768").schema(); + this.f7690 = readerSchema.getField("F769").schema(); + this.f7700 = readerSchema.getField("F770").schema(); + this.f7710 = readerSchema.getField("F771").schema(); + this.f7720 = readerSchema.getField("F772").schema(); + this.f7730 = readerSchema.getField("F773").schema(); + this.f7740 = readerSchema.getField("F774").schema(); + this.f7750 = readerSchema.getField("F775").schema(); + this.f7760 = readerSchema.getField("F776").schema(); + this.f7770 = readerSchema.getField("F777").schema(); + this.f7780 = readerSchema.getField("F778").schema(); + this.f7790 = readerSchema.getField("F779").schema(); + this.f7800 = readerSchema.getField("F780").schema(); + this.f7810 = readerSchema.getField("F781").schema(); + this.f7820 = readerSchema.getField("F782").schema(); + this.f7830 = readerSchema.getField("F783").schema(); + this.f7840 = readerSchema.getField("F784").schema(); + this.f7850 = readerSchema.getField("F785").schema(); + this.f7860 = readerSchema.getField("F786").schema(); + this.f7870 = readerSchema.getField("F787").schema(); + this.f7880 = readerSchema.getField("F788").schema(); + this.f7890 = readerSchema.getField("F789").schema(); + this.f7900 = readerSchema.getField("F790").schema(); + this.f7910 = readerSchema.getField("F791").schema(); + this.f7920 = readerSchema.getField("F792").schema(); + this.f7930 = readerSchema.getField("F793").schema(); + this.f7940 = readerSchema.getField("F794").schema(); + this.f7950 = readerSchema.getField("F795").schema(); + this.f7960 = readerSchema.getField("F796").schema(); + this.f7970 = readerSchema.getField("F797").schema(); + this.f7980 = readerSchema.getField("F798").schema(); + this.f7990 = readerSchema.getField("F799").schema(); + this.f8000 = readerSchema.getField("F800").schema(); + this.f8010 = readerSchema.getField("F801").schema(); + this.f8020 = readerSchema.getField("F802").schema(); + this.f8030 = readerSchema.getField("F803").schema(); + this.f8040 = readerSchema.getField("F804").schema(); + this.f8050 = readerSchema.getField("F805").schema(); + this.f8060 = readerSchema.getField("F806").schema(); + this.f8070 = readerSchema.getField("F807").schema(); + this.f8080 = readerSchema.getField("F808").schema(); + this.f8090 = readerSchema.getField("F809").schema(); + this.f8100 = readerSchema.getField("F810").schema(); + this.f8110 = readerSchema.getField("F811").schema(); + this.f8120 = readerSchema.getField("F812").schema(); + this.f8130 = readerSchema.getField("F813").schema(); + this.f8140 = readerSchema.getField("F814").schema(); + this.f8150 = readerSchema.getField("F815").schema(); + this.f8160 = readerSchema.getField("F816").schema(); + this.f8170 = readerSchema.getField("F817").schema(); + this.f8180 = readerSchema.getField("F818").schema(); + this.f8190 = readerSchema.getField("F819").schema(); + this.f8200 = readerSchema.getField("F820").schema(); + this.f8210 = readerSchema.getField("F821").schema(); + this.f8220 = readerSchema.getField("F822").schema(); + this.f8230 = readerSchema.getField("F823").schema(); + this.f8240 = readerSchema.getField("F824").schema(); + this.f8250 = readerSchema.getField("F825").schema(); + this.f8260 = readerSchema.getField("F826").schema(); + this.f8270 = readerSchema.getField("F827").schema(); + this.f8280 = readerSchema.getField("F828").schema(); + this.f8290 = readerSchema.getField("F829").schema(); + this.f8300 = readerSchema.getField("F830").schema(); + this.f8310 = readerSchema.getField("F831").schema(); + this.f8320 = readerSchema.getField("F832").schema(); + this.f8330 = readerSchema.getField("F833").schema(); + this.f8340 = readerSchema.getField("F834").schema(); + this.f8350 = readerSchema.getField("F835").schema(); + this.f8360 = readerSchema.getField("F836").schema(); + this.f8370 = readerSchema.getField("F837").schema(); + this.f8380 = readerSchema.getField("F838").schema(); + this.f8390 = readerSchema.getField("F839").schema(); + this.f8400 = readerSchema.getField("F840").schema(); + this.f8410 = readerSchema.getField("F841").schema(); + this.f8420 = readerSchema.getField("F842").schema(); + this.f8430 = readerSchema.getField("F843").schema(); + this.f8440 = readerSchema.getField("F844").schema(); + this.f8450 = readerSchema.getField("F845").schema(); + this.f8460 = readerSchema.getField("F846").schema(); + this.f8470 = readerSchema.getField("F847").schema(); + this.f8480 = readerSchema.getField("F848").schema(); + this.f8490 = readerSchema.getField("F849").schema(); + this.f8500 = readerSchema.getField("F850").schema(); + this.f8510 = readerSchema.getField("F851").schema(); + this.f8520 = readerSchema.getField("F852").schema(); + this.f8530 = readerSchema.getField("F853").schema(); + this.f8540 = readerSchema.getField("F854").schema(); + this.f8550 = readerSchema.getField("F855").schema(); + this.f8560 = readerSchema.getField("F856").schema(); + this.f8570 = readerSchema.getField("F857").schema(); + this.f8580 = readerSchema.getField("F858").schema(); + this.f8590 = readerSchema.getField("F859").schema(); + this.f8600 = readerSchema.getField("F860").schema(); + this.f8610 = readerSchema.getField("F861").schema(); + this.f8620 = readerSchema.getField("F862").schema(); + this.f8630 = readerSchema.getField("F863").schema(); + this.f8640 = readerSchema.getField("F864").schema(); + this.f8650 = readerSchema.getField("F865").schema(); + this.f8660 = readerSchema.getField("F866").schema(); + this.f8670 = readerSchema.getField("F867").schema(); + this.f8680 = readerSchema.getField("F868").schema(); + this.f8690 = readerSchema.getField("F869").schema(); + this.f8700 = readerSchema.getField("F870").schema(); + this.f8710 = readerSchema.getField("F871").schema(); + this.f8720 = readerSchema.getField("F872").schema(); + this.f8730 = readerSchema.getField("F873").schema(); + this.f8740 = readerSchema.getField("F874").schema(); + this.f8750 = readerSchema.getField("F875").schema(); + this.f8760 = readerSchema.getField("F876").schema(); + this.f8770 = readerSchema.getField("F877").schema(); + this.f8780 = readerSchema.getField("F878").schema(); + this.f8790 = readerSchema.getField("F879").schema(); + this.f8800 = readerSchema.getField("F880").schema(); + this.f8810 = readerSchema.getField("F881").schema(); + this.f8820 = readerSchema.getField("F882").schema(); + this.f8830 = readerSchema.getField("F883").schema(); + this.f8840 = readerSchema.getField("F884").schema(); + this.f8850 = readerSchema.getField("F885").schema(); + this.f8860 = readerSchema.getField("F886").schema(); + this.f8870 = readerSchema.getField("F887").schema(); + this.f8880 = readerSchema.getField("F888").schema(); + this.f8890 = readerSchema.getField("F889").schema(); + this.f8900 = readerSchema.getField("F890").schema(); + this.f8910 = readerSchema.getField("F891").schema(); + this.f8920 = readerSchema.getField("F892").schema(); + this.f8930 = readerSchema.getField("F893").schema(); + this.f8940 = readerSchema.getField("F894").schema(); + this.f8950 = readerSchema.getField("F895").schema(); + this.f8960 = readerSchema.getField("F896").schema(); + this.f8970 = readerSchema.getField("F897").schema(); + this.f8980 = readerSchema.getField("F898").schema(); + this.f8990 = readerSchema.getField("F899").schema(); + this.f9000 = readerSchema.getField("F900").schema(); + this.f9010 = readerSchema.getField("F901").schema(); + this.f9020 = readerSchema.getField("F902").schema(); + this.f9030 = readerSchema.getField("F903").schema(); + this.f9040 = readerSchema.getField("F904").schema(); + this.f9050 = readerSchema.getField("F905").schema(); + this.f9060 = readerSchema.getField("F906").schema(); + this.f9070 = readerSchema.getField("F907").schema(); + this.f9080 = readerSchema.getField("F908").schema(); + this.f9090 = readerSchema.getField("F909").schema(); + this.f9100 = readerSchema.getField("F910").schema(); + this.f9110 = readerSchema.getField("F911").schema(); + this.f9120 = readerSchema.getField("F912").schema(); + this.f9130 = readerSchema.getField("F913").schema(); + this.f9140 = readerSchema.getField("F914").schema(); + this.f9150 = readerSchema.getField("F915").schema(); + this.f9160 = readerSchema.getField("F916").schema(); + this.f9170 = readerSchema.getField("F917").schema(); + this.f9180 = readerSchema.getField("F918").schema(); + this.f9190 = readerSchema.getField("F919").schema(); + this.f9200 = readerSchema.getField("F920").schema(); + this.f9210 = readerSchema.getField("F921").schema(); + this.f9220 = readerSchema.getField("F922").schema(); + this.f9230 = readerSchema.getField("F923").schema(); + this.f9240 = readerSchema.getField("F924").schema(); + this.f9250 = readerSchema.getField("F925").schema(); + this.f9260 = readerSchema.getField("F926").schema(); + this.f9270 = readerSchema.getField("F927").schema(); + this.f9280 = readerSchema.getField("F928").schema(); + this.f9290 = readerSchema.getField("F929").schema(); + this.f9300 = readerSchema.getField("F930").schema(); + this.f9310 = readerSchema.getField("F931").schema(); + this.f9320 = readerSchema.getField("F932").schema(); + this.f9330 = readerSchema.getField("F933").schema(); + this.f9340 = readerSchema.getField("F934").schema(); + this.f9350 = readerSchema.getField("F935").schema(); + this.f9360 = readerSchema.getField("F936").schema(); + this.f9370 = readerSchema.getField("F937").schema(); + this.f9380 = readerSchema.getField("F938").schema(); + this.f9390 = readerSchema.getField("F939").schema(); + this.f9400 = readerSchema.getField("F940").schema(); + this.f9410 = readerSchema.getField("F941").schema(); + this.f9420 = readerSchema.getField("F942").schema(); + this.f9430 = readerSchema.getField("F943").schema(); + this.f9440 = readerSchema.getField("F944").schema(); + this.f9450 = readerSchema.getField("F945").schema(); + this.f9460 = readerSchema.getField("F946").schema(); + this.f9470 = readerSchema.getField("F947").schema(); + this.f9480 = readerSchema.getField("F948").schema(); + this.f9490 = readerSchema.getField("F949").schema(); + this.f9500 = readerSchema.getField("F950").schema(); + this.f9510 = readerSchema.getField("F951").schema(); + this.f9520 = readerSchema.getField("F952").schema(); + this.f9530 = readerSchema.getField("F953").schema(); + this.f9540 = readerSchema.getField("F954").schema(); + this.f9550 = readerSchema.getField("F955").schema(); + this.f9560 = readerSchema.getField("F956").schema(); + this.f9570 = readerSchema.getField("F957").schema(); + this.f9580 = readerSchema.getField("F958").schema(); + this.f9590 = readerSchema.getField("F959").schema(); + this.f9600 = readerSchema.getField("F960").schema(); + this.f9610 = readerSchema.getField("F961").schema(); + this.f9620 = readerSchema.getField("F962").schema(); + this.f9630 = readerSchema.getField("F963").schema(); + this.f9640 = readerSchema.getField("F964").schema(); + this.f9650 = readerSchema.getField("F965").schema(); + this.f9660 = readerSchema.getField("F966").schema(); + this.f9670 = readerSchema.getField("F967").schema(); + this.f9680 = readerSchema.getField("F968").schema(); + this.f9690 = readerSchema.getField("F969").schema(); + this.f9700 = readerSchema.getField("F970").schema(); + this.f9710 = readerSchema.getField("F971").schema(); + this.f9720 = readerSchema.getField("F972").schema(); + this.f9730 = readerSchema.getField("F973").schema(); + this.f9740 = readerSchema.getField("F974").schema(); + this.f9750 = readerSchema.getField("F975").schema(); + this.f9760 = readerSchema.getField("F976").schema(); + this.f9770 = readerSchema.getField("F977").schema(); + this.f9780 = readerSchema.getField("F978").schema(); + this.f9790 = readerSchema.getField("F979").schema(); + this.f9800 = readerSchema.getField("F980").schema(); + this.f9810 = readerSchema.getField("F981").schema(); + this.f9820 = readerSchema.getField("F982").schema(); + this.f9830 = readerSchema.getField("F983").schema(); + this.f9840 = readerSchema.getField("F984").schema(); + this.f9850 = readerSchema.getField("F985").schema(); + this.f9860 = readerSchema.getField("F986").schema(); + this.f9870 = readerSchema.getField("F987").schema(); + this.f9880 = readerSchema.getField("F988").schema(); + this.f9890 = readerSchema.getField("F989").schema(); + this.f9900 = readerSchema.getField("F990").schema(); + this.f9910 = readerSchema.getField("F991").schema(); + this.f9920 = readerSchema.getField("F992").schema(); + this.f9930 = readerSchema.getField("F993").schema(); + this.f9940 = readerSchema.getField("F994").schema(); + this.f9950 = readerSchema.getField("F995").schema(); + this.f9960 = readerSchema.getField("F996").schema(); + this.f9970 = readerSchema.getField("F997").schema(); + this.f9980 = readerSchema.getField("F998").schema(); + this.f9990 = readerSchema.getField("F999").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'F0': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(1, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'F1': "+ unionIndex1)); + } + } + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(2, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence2; + Object oldString2 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(2); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(2, charSequence2); + } else { + throw new RuntimeException(("Illegal union index for 'F2': "+ unionIndex2)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(3, null); + } else { + if (unionIndex3 == 1) { + Utf8 charSequence3; + Object oldString3 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(3); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(3, charSequence3); + } else { + throw new RuntimeException(("Illegal union index for 'F3': "+ unionIndex3)); + } + } + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(4, null); + } else { + if (unionIndex4 == 1) { + Utf8 charSequence4; + Object oldString4 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(4); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(4, charSequence4); + } else { + throw new RuntimeException(("Illegal union index for 'F4': "+ unionIndex4)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(5, null); + } else { + if (unionIndex5 == 1) { + Utf8 charSequence5; + Object oldString5 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(5); + if (oldString5 instanceof Utf8) { + charSequence5 = (decoder).readString(((Utf8) oldString5)); + } else { + charSequence5 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(5, charSequence5); + } else { + throw new RuntimeException(("Illegal union index for 'F5': "+ unionIndex5)); + } + } + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(6, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence6; + Object oldString6 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(6); + if (oldString6 instanceof Utf8) { + charSequence6 = (decoder).readString(((Utf8) oldString6)); + } else { + charSequence6 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(6, charSequence6); + } else { + throw new RuntimeException(("Illegal union index for 'F6': "+ unionIndex6)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(7, null); + } else { + if (unionIndex7 == 1) { + Utf8 charSequence7; + Object oldString7 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(7); + if (oldString7 instanceof Utf8) { + charSequence7 = (decoder).readString(((Utf8) oldString7)); + } else { + charSequence7 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(7, charSequence7); + } else { + throw new RuntimeException(("Illegal union index for 'F7': "+ unionIndex7)); + } + } + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(8, null); + } else { + if (unionIndex8 == 1) { + Utf8 charSequence8; + Object oldString8 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(8); + if (oldString8 instanceof Utf8) { + charSequence8 = (decoder).readString(((Utf8) oldString8)); + } else { + charSequence8 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(8, charSequence8); + } else { + throw new RuntimeException(("Illegal union index for 'F8': "+ unionIndex8)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex9 = (decoder.readIndex()); + if (unionIndex9 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(9, null); + } else { + if (unionIndex9 == 1) { + Utf8 charSequence9; + Object oldString9 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(9); + if (oldString9 instanceof Utf8) { + charSequence9 = (decoder).readString(((Utf8) oldString9)); + } else { + charSequence9 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(9, charSequence9); + } else { + throw new RuntimeException(("Illegal union index for 'F9': "+ unionIndex9)); + } + } + int unionIndex10 = (decoder.readIndex()); + if (unionIndex10 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(10, null); + } else { + if (unionIndex10 == 1) { + Utf8 charSequence10; + Object oldString10 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(10); + if (oldString10 instanceof Utf8) { + charSequence10 = (decoder).readString(((Utf8) oldString10)); + } else { + charSequence10 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(10, charSequence10); + } else { + throw new RuntimeException(("Illegal union index for 'F10': "+ unionIndex10)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex11 = (decoder.readIndex()); + if (unionIndex11 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(11, null); + } else { + if (unionIndex11 == 1) { + Utf8 charSequence11; + Object oldString11 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(11); + if (oldString11 instanceof Utf8) { + charSequence11 = (decoder).readString(((Utf8) oldString11)); + } else { + charSequence11 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(11, charSequence11); + } else { + throw new RuntimeException(("Illegal union index for 'F11': "+ unionIndex11)); + } + } + int unionIndex12 = (decoder.readIndex()); + if (unionIndex12 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(12, null); + } else { + if (unionIndex12 == 1) { + Utf8 charSequence12; + Object oldString12 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(12); + if (oldString12 instanceof Utf8) { + charSequence12 = (decoder).readString(((Utf8) oldString12)); + } else { + charSequence12 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(12, charSequence12); + } else { + throw new RuntimeException(("Illegal union index for 'F12': "+ unionIndex12)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex13 = (decoder.readIndex()); + if (unionIndex13 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(13, null); + } else { + if (unionIndex13 == 1) { + Utf8 charSequence13; + Object oldString13 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(13); + if (oldString13 instanceof Utf8) { + charSequence13 = (decoder).readString(((Utf8) oldString13)); + } else { + charSequence13 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(13, charSequence13); + } else { + throw new RuntimeException(("Illegal union index for 'F13': "+ unionIndex13)); + } + } + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(14, null); + } else { + if (unionIndex14 == 1) { + Utf8 charSequence14; + Object oldString14 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(14); + if (oldString14 instanceof Utf8) { + charSequence14 = (decoder).readString(((Utf8) oldString14)); + } else { + charSequence14 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(14, charSequence14); + } else { + throw new RuntimeException(("Illegal union index for 'F14': "+ unionIndex14)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(15, null); + } else { + if (unionIndex15 == 1) { + Utf8 charSequence15; + Object oldString15 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(15); + if (oldString15 instanceof Utf8) { + charSequence15 = (decoder).readString(((Utf8) oldString15)); + } else { + charSequence15 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(15, charSequence15); + } else { + throw new RuntimeException(("Illegal union index for 'F15': "+ unionIndex15)); + } + } + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(16, null); + } else { + if (unionIndex16 == 1) { + Utf8 charSequence16; + Object oldString16 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(16); + if (oldString16 instanceof Utf8) { + charSequence16 = (decoder).readString(((Utf8) oldString16)); + } else { + charSequence16 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(16, charSequence16); + } else { + throw new RuntimeException(("Illegal union index for 'F16': "+ unionIndex16)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex17 = (decoder.readIndex()); + if (unionIndex17 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(17, null); + } else { + if (unionIndex17 == 1) { + Utf8 charSequence17; + Object oldString17 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(17); + if (oldString17 instanceof Utf8) { + charSequence17 = (decoder).readString(((Utf8) oldString17)); + } else { + charSequence17 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(17, charSequence17); + } else { + throw new RuntimeException(("Illegal union index for 'F17': "+ unionIndex17)); + } + } + int unionIndex18 = (decoder.readIndex()); + if (unionIndex18 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(18, null); + } else { + if (unionIndex18 == 1) { + Utf8 charSequence18; + Object oldString18 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(18); + if (oldString18 instanceof Utf8) { + charSequence18 = (decoder).readString(((Utf8) oldString18)); + } else { + charSequence18 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(18, charSequence18); + } else { + throw new RuntimeException(("Illegal union index for 'F18': "+ unionIndex18)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex19 = (decoder.readIndex()); + if (unionIndex19 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(19, null); + } else { + if (unionIndex19 == 1) { + Utf8 charSequence19; + Object oldString19 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(19); + if (oldString19 instanceof Utf8) { + charSequence19 = (decoder).readString(((Utf8) oldString19)); + } else { + charSequence19 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(19, charSequence19); + } else { + throw new RuntimeException(("Illegal union index for 'F19': "+ unionIndex19)); + } + } + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(20, null); + } else { + if (unionIndex20 == 1) { + Utf8 charSequence20; + Object oldString20 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(20); + if (oldString20 instanceof Utf8) { + charSequence20 = (decoder).readString(((Utf8) oldString20)); + } else { + charSequence20 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(20, charSequence20); + } else { + throw new RuntimeException(("Illegal union index for 'F20': "+ unionIndex20)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(21, null); + } else { + if (unionIndex21 == 1) { + Utf8 charSequence21; + Object oldString21 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(21); + if (oldString21 instanceof Utf8) { + charSequence21 = (decoder).readString(((Utf8) oldString21)); + } else { + charSequence21 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(21, charSequence21); + } else { + throw new RuntimeException(("Illegal union index for 'F21': "+ unionIndex21)); + } + } + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(22, null); + } else { + if (unionIndex22 == 1) { + Utf8 charSequence22; + Object oldString22 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(22); + if (oldString22 instanceof Utf8) { + charSequence22 = (decoder).readString(((Utf8) oldString22)); + } else { + charSequence22 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(22, charSequence22); + } else { + throw new RuntimeException(("Illegal union index for 'F22': "+ unionIndex22)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(23, null); + } else { + if (unionIndex23 == 1) { + Utf8 charSequence23; + Object oldString23 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(23); + if (oldString23 instanceof Utf8) { + charSequence23 = (decoder).readString(((Utf8) oldString23)); + } else { + charSequence23 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(23, charSequence23); + } else { + throw new RuntimeException(("Illegal union index for 'F23': "+ unionIndex23)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(24, null); + } else { + if (unionIndex24 == 1) { + Utf8 charSequence24; + Object oldString24 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(24); + if (oldString24 instanceof Utf8) { + charSequence24 = (decoder).readString(((Utf8) oldString24)); + } else { + charSequence24 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(24, charSequence24); + } else { + throw new RuntimeException(("Illegal union index for 'F24': "+ unionIndex24)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(25, null); + } else { + if (unionIndex25 == 1) { + Utf8 charSequence25; + Object oldString25 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(25); + if (oldString25 instanceof Utf8) { + charSequence25 = (decoder).readString(((Utf8) oldString25)); + } else { + charSequence25 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(25, charSequence25); + } else { + throw new RuntimeException(("Illegal union index for 'F25': "+ unionIndex25)); + } + } + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(26, null); + } else { + if (unionIndex26 == 1) { + Utf8 charSequence26; + Object oldString26 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(26); + if (oldString26 instanceof Utf8) { + charSequence26 = (decoder).readString(((Utf8) oldString26)); + } else { + charSequence26 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(26, charSequence26); + } else { + throw new RuntimeException(("Illegal union index for 'F26': "+ unionIndex26)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex27 = (decoder.readIndex()); + if (unionIndex27 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(27, null); + } else { + if (unionIndex27 == 1) { + Utf8 charSequence27; + Object oldString27 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(27); + if (oldString27 instanceof Utf8) { + charSequence27 = (decoder).readString(((Utf8) oldString27)); + } else { + charSequence27 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(27, charSequence27); + } else { + throw new RuntimeException(("Illegal union index for 'F27': "+ unionIndex27)); + } + } + int unionIndex28 = (decoder.readIndex()); + if (unionIndex28 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(28, null); + } else { + if (unionIndex28 == 1) { + Utf8 charSequence28; + Object oldString28 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(28); + if (oldString28 instanceof Utf8) { + charSequence28 = (decoder).readString(((Utf8) oldString28)); + } else { + charSequence28 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(28, charSequence28); + } else { + throw new RuntimeException(("Illegal union index for 'F28': "+ unionIndex28)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex29 = (decoder.readIndex()); + if (unionIndex29 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(29, null); + } else { + if (unionIndex29 == 1) { + Utf8 charSequence29; + Object oldString29 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(29); + if (oldString29 instanceof Utf8) { + charSequence29 = (decoder).readString(((Utf8) oldString29)); + } else { + charSequence29 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(29, charSequence29); + } else { + throw new RuntimeException(("Illegal union index for 'F29': "+ unionIndex29)); + } + } + int unionIndex30 = (decoder.readIndex()); + if (unionIndex30 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(30, null); + } else { + if (unionIndex30 == 1) { + Utf8 charSequence30; + Object oldString30 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(30); + if (oldString30 instanceof Utf8) { + charSequence30 = (decoder).readString(((Utf8) oldString30)); + } else { + charSequence30 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(30, charSequence30); + } else { + throw new RuntimeException(("Illegal union index for 'F30': "+ unionIndex30)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex31 = (decoder.readIndex()); + if (unionIndex31 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(31, null); + } else { + if (unionIndex31 == 1) { + Utf8 charSequence31; + Object oldString31 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(31); + if (oldString31 instanceof Utf8) { + charSequence31 = (decoder).readString(((Utf8) oldString31)); + } else { + charSequence31 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(31, charSequence31); + } else { + throw new RuntimeException(("Illegal union index for 'F31': "+ unionIndex31)); + } + } + int unionIndex32 = (decoder.readIndex()); + if (unionIndex32 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(32, null); + } else { + if (unionIndex32 == 1) { + Utf8 charSequence32; + Object oldString32 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(32); + if (oldString32 instanceof Utf8) { + charSequence32 = (decoder).readString(((Utf8) oldString32)); + } else { + charSequence32 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(32, charSequence32); + } else { + throw new RuntimeException(("Illegal union index for 'F32': "+ unionIndex32)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex33 = (decoder.readIndex()); + if (unionIndex33 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(33, null); + } else { + if (unionIndex33 == 1) { + Utf8 charSequence33; + Object oldString33 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(33); + if (oldString33 instanceof Utf8) { + charSequence33 = (decoder).readString(((Utf8) oldString33)); + } else { + charSequence33 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(33, charSequence33); + } else { + throw new RuntimeException(("Illegal union index for 'F33': "+ unionIndex33)); + } + } + int unionIndex34 = (decoder.readIndex()); + if (unionIndex34 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(34, null); + } else { + if (unionIndex34 == 1) { + Utf8 charSequence34; + Object oldString34 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(34); + if (oldString34 instanceof Utf8) { + charSequence34 = (decoder).readString(((Utf8) oldString34)); + } else { + charSequence34 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(34, charSequence34); + } else { + throw new RuntimeException(("Illegal union index for 'F34': "+ unionIndex34)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex35 = (decoder.readIndex()); + if (unionIndex35 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(35, null); + } else { + if (unionIndex35 == 1) { + Utf8 charSequence35; + Object oldString35 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(35); + if (oldString35 instanceof Utf8) { + charSequence35 = (decoder).readString(((Utf8) oldString35)); + } else { + charSequence35 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(35, charSequence35); + } else { + throw new RuntimeException(("Illegal union index for 'F35': "+ unionIndex35)); + } + } + int unionIndex36 = (decoder.readIndex()); + if (unionIndex36 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(36, null); + } else { + if (unionIndex36 == 1) { + Utf8 charSequence36; + Object oldString36 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(36); + if (oldString36 instanceof Utf8) { + charSequence36 = (decoder).readString(((Utf8) oldString36)); + } else { + charSequence36 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(36, charSequence36); + } else { + throw new RuntimeException(("Illegal union index for 'F36': "+ unionIndex36)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex37 = (decoder.readIndex()); + if (unionIndex37 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(37, null); + } else { + if (unionIndex37 == 1) { + Utf8 charSequence37; + Object oldString37 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(37); + if (oldString37 instanceof Utf8) { + charSequence37 = (decoder).readString(((Utf8) oldString37)); + } else { + charSequence37 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(37, charSequence37); + } else { + throw new RuntimeException(("Illegal union index for 'F37': "+ unionIndex37)); + } + } + int unionIndex38 = (decoder.readIndex()); + if (unionIndex38 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(38, null); + } else { + if (unionIndex38 == 1) { + Utf8 charSequence38; + Object oldString38 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(38); + if (oldString38 instanceof Utf8) { + charSequence38 = (decoder).readString(((Utf8) oldString38)); + } else { + charSequence38 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(38, charSequence38); + } else { + throw new RuntimeException(("Illegal union index for 'F38': "+ unionIndex38)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex39 = (decoder.readIndex()); + if (unionIndex39 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(39, null); + } else { + if (unionIndex39 == 1) { + Utf8 charSequence39; + Object oldString39 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(39); + if (oldString39 instanceof Utf8) { + charSequence39 = (decoder).readString(((Utf8) oldString39)); + } else { + charSequence39 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(39, charSequence39); + } else { + throw new RuntimeException(("Illegal union index for 'F39': "+ unionIndex39)); + } + } + int unionIndex40 = (decoder.readIndex()); + if (unionIndex40 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(40, null); + } else { + if (unionIndex40 == 1) { + Utf8 charSequence40; + Object oldString40 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(40); + if (oldString40 instanceof Utf8) { + charSequence40 = (decoder).readString(((Utf8) oldString40)); + } else { + charSequence40 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(40, charSequence40); + } else { + throw new RuntimeException(("Illegal union index for 'F40': "+ unionIndex40)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex41 = (decoder.readIndex()); + if (unionIndex41 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(41, null); + } else { + if (unionIndex41 == 1) { + Utf8 charSequence41; + Object oldString41 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(41); + if (oldString41 instanceof Utf8) { + charSequence41 = (decoder).readString(((Utf8) oldString41)); + } else { + charSequence41 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(41, charSequence41); + } else { + throw new RuntimeException(("Illegal union index for 'F41': "+ unionIndex41)); + } + } + int unionIndex42 = (decoder.readIndex()); + if (unionIndex42 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(42, null); + } else { + if (unionIndex42 == 1) { + Utf8 charSequence42; + Object oldString42 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(42); + if (oldString42 instanceof Utf8) { + charSequence42 = (decoder).readString(((Utf8) oldString42)); + } else { + charSequence42 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(42, charSequence42); + } else { + throw new RuntimeException(("Illegal union index for 'F42': "+ unionIndex42)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex43 = (decoder.readIndex()); + if (unionIndex43 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(43, null); + } else { + if (unionIndex43 == 1) { + Utf8 charSequence43; + Object oldString43 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(43); + if (oldString43 instanceof Utf8) { + charSequence43 = (decoder).readString(((Utf8) oldString43)); + } else { + charSequence43 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(43, charSequence43); + } else { + throw new RuntimeException(("Illegal union index for 'F43': "+ unionIndex43)); + } + } + int unionIndex44 = (decoder.readIndex()); + if (unionIndex44 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(44, null); + } else { + if (unionIndex44 == 1) { + Utf8 charSequence44; + Object oldString44 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(44); + if (oldString44 instanceof Utf8) { + charSequence44 = (decoder).readString(((Utf8) oldString44)); + } else { + charSequence44 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(44, charSequence44); + } else { + throw new RuntimeException(("Illegal union index for 'F44': "+ unionIndex44)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex45 = (decoder.readIndex()); + if (unionIndex45 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(45, null); + } else { + if (unionIndex45 == 1) { + Utf8 charSequence45; + Object oldString45 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(45); + if (oldString45 instanceof Utf8) { + charSequence45 = (decoder).readString(((Utf8) oldString45)); + } else { + charSequence45 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(45, charSequence45); + } else { + throw new RuntimeException(("Illegal union index for 'F45': "+ unionIndex45)); + } + } + int unionIndex46 = (decoder.readIndex()); + if (unionIndex46 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(46, null); + } else { + if (unionIndex46 == 1) { + Utf8 charSequence46; + Object oldString46 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(46); + if (oldString46 instanceof Utf8) { + charSequence46 = (decoder).readString(((Utf8) oldString46)); + } else { + charSequence46 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(46, charSequence46); + } else { + throw new RuntimeException(("Illegal union index for 'F46': "+ unionIndex46)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex47 = (decoder.readIndex()); + if (unionIndex47 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(47, null); + } else { + if (unionIndex47 == 1) { + Utf8 charSequence47; + Object oldString47 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(47); + if (oldString47 instanceof Utf8) { + charSequence47 = (decoder).readString(((Utf8) oldString47)); + } else { + charSequence47 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(47, charSequence47); + } else { + throw new RuntimeException(("Illegal union index for 'F47': "+ unionIndex47)); + } + } + int unionIndex48 = (decoder.readIndex()); + if (unionIndex48 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(48, null); + } else { + if (unionIndex48 == 1) { + Utf8 charSequence48; + Object oldString48 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(48); + if (oldString48 instanceof Utf8) { + charSequence48 = (decoder).readString(((Utf8) oldString48)); + } else { + charSequence48 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(48, charSequence48); + } else { + throw new RuntimeException(("Illegal union index for 'F48': "+ unionIndex48)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex49 = (decoder.readIndex()); + if (unionIndex49 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(49, null); + } else { + if (unionIndex49 == 1) { + Utf8 charSequence49; + Object oldString49 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(49); + if (oldString49 instanceof Utf8) { + charSequence49 = (decoder).readString(((Utf8) oldString49)); + } else { + charSequence49 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(49, charSequence49); + } else { + throw new RuntimeException(("Illegal union index for 'F49': "+ unionIndex49)); + } + } + int unionIndex50 = (decoder.readIndex()); + if (unionIndex50 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(50, null); + } else { + if (unionIndex50 == 1) { + Utf8 charSequence50; + Object oldString50 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(50); + if (oldString50 instanceof Utf8) { + charSequence50 = (decoder).readString(((Utf8) oldString50)); + } else { + charSequence50 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(50, charSequence50); + } else { + throw new RuntimeException(("Illegal union index for 'F50': "+ unionIndex50)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex51 = (decoder.readIndex()); + if (unionIndex51 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(51, null); + } else { + if (unionIndex51 == 1) { + Utf8 charSequence51; + Object oldString51 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(51); + if (oldString51 instanceof Utf8) { + charSequence51 = (decoder).readString(((Utf8) oldString51)); + } else { + charSequence51 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(51, charSequence51); + } else { + throw new RuntimeException(("Illegal union index for 'F51': "+ unionIndex51)); + } + } + int unionIndex52 = (decoder.readIndex()); + if (unionIndex52 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(52, null); + } else { + if (unionIndex52 == 1) { + Utf8 charSequence52; + Object oldString52 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(52); + if (oldString52 instanceof Utf8) { + charSequence52 = (decoder).readString(((Utf8) oldString52)); + } else { + charSequence52 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(52, charSequence52); + } else { + throw new RuntimeException(("Illegal union index for 'F52': "+ unionIndex52)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex53 = (decoder.readIndex()); + if (unionIndex53 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(53, null); + } else { + if (unionIndex53 == 1) { + Utf8 charSequence53; + Object oldString53 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(53); + if (oldString53 instanceof Utf8) { + charSequence53 = (decoder).readString(((Utf8) oldString53)); + } else { + charSequence53 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(53, charSequence53); + } else { + throw new RuntimeException(("Illegal union index for 'F53': "+ unionIndex53)); + } + } + int unionIndex54 = (decoder.readIndex()); + if (unionIndex54 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(54, null); + } else { + if (unionIndex54 == 1) { + Utf8 charSequence54; + Object oldString54 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(54); + if (oldString54 instanceof Utf8) { + charSequence54 = (decoder).readString(((Utf8) oldString54)); + } else { + charSequence54 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(54, charSequence54); + } else { + throw new RuntimeException(("Illegal union index for 'F54': "+ unionIndex54)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex55 = (decoder.readIndex()); + if (unionIndex55 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(55, null); + } else { + if (unionIndex55 == 1) { + Utf8 charSequence55; + Object oldString55 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(55); + if (oldString55 instanceof Utf8) { + charSequence55 = (decoder).readString(((Utf8) oldString55)); + } else { + charSequence55 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(55, charSequence55); + } else { + throw new RuntimeException(("Illegal union index for 'F55': "+ unionIndex55)); + } + } + int unionIndex56 = (decoder.readIndex()); + if (unionIndex56 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(56, null); + } else { + if (unionIndex56 == 1) { + Utf8 charSequence56; + Object oldString56 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(56); + if (oldString56 instanceof Utf8) { + charSequence56 = (decoder).readString(((Utf8) oldString56)); + } else { + charSequence56 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(56, charSequence56); + } else { + throw new RuntimeException(("Illegal union index for 'F56': "+ unionIndex56)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex57 = (decoder.readIndex()); + if (unionIndex57 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(57, null); + } else { + if (unionIndex57 == 1) { + Utf8 charSequence57; + Object oldString57 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(57); + if (oldString57 instanceof Utf8) { + charSequence57 = (decoder).readString(((Utf8) oldString57)); + } else { + charSequence57 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(57, charSequence57); + } else { + throw new RuntimeException(("Illegal union index for 'F57': "+ unionIndex57)); + } + } + int unionIndex58 = (decoder.readIndex()); + if (unionIndex58 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(58, null); + } else { + if (unionIndex58 == 1) { + Utf8 charSequence58; + Object oldString58 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(58); + if (oldString58 instanceof Utf8) { + charSequence58 = (decoder).readString(((Utf8) oldString58)); + } else { + charSequence58 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(58, charSequence58); + } else { + throw new RuntimeException(("Illegal union index for 'F58': "+ unionIndex58)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex59 = (decoder.readIndex()); + if (unionIndex59 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(59, null); + } else { + if (unionIndex59 == 1) { + Utf8 charSequence59; + Object oldString59 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(59); + if (oldString59 instanceof Utf8) { + charSequence59 = (decoder).readString(((Utf8) oldString59)); + } else { + charSequence59 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(59, charSequence59); + } else { + throw new RuntimeException(("Illegal union index for 'F59': "+ unionIndex59)); + } + } + int unionIndex60 = (decoder.readIndex()); + if (unionIndex60 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(60, null); + } else { + if (unionIndex60 == 1) { + Utf8 charSequence60; + Object oldString60 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(60); + if (oldString60 instanceof Utf8) { + charSequence60 = (decoder).readString(((Utf8) oldString60)); + } else { + charSequence60 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(60, charSequence60); + } else { + throw new RuntimeException(("Illegal union index for 'F60': "+ unionIndex60)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex61 = (decoder.readIndex()); + if (unionIndex61 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(61, null); + } else { + if (unionIndex61 == 1) { + Utf8 charSequence61; + Object oldString61 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(61); + if (oldString61 instanceof Utf8) { + charSequence61 = (decoder).readString(((Utf8) oldString61)); + } else { + charSequence61 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(61, charSequence61); + } else { + throw new RuntimeException(("Illegal union index for 'F61': "+ unionIndex61)); + } + } + int unionIndex62 = (decoder.readIndex()); + if (unionIndex62 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(62, null); + } else { + if (unionIndex62 == 1) { + Utf8 charSequence62; + Object oldString62 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(62); + if (oldString62 instanceof Utf8) { + charSequence62 = (decoder).readString(((Utf8) oldString62)); + } else { + charSequence62 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(62, charSequence62); + } else { + throw new RuntimeException(("Illegal union index for 'F62': "+ unionIndex62)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex63 = (decoder.readIndex()); + if (unionIndex63 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(63, null); + } else { + if (unionIndex63 == 1) { + Utf8 charSequence63; + Object oldString63 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(63); + if (oldString63 instanceof Utf8) { + charSequence63 = (decoder).readString(((Utf8) oldString63)); + } else { + charSequence63 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(63, charSequence63); + } else { + throw new RuntimeException(("Illegal union index for 'F63': "+ unionIndex63)); + } + } + int unionIndex64 = (decoder.readIndex()); + if (unionIndex64 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(64, null); + } else { + if (unionIndex64 == 1) { + Utf8 charSequence64; + Object oldString64 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(64); + if (oldString64 instanceof Utf8) { + charSequence64 = (decoder).readString(((Utf8) oldString64)); + } else { + charSequence64 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(64, charSequence64); + } else { + throw new RuntimeException(("Illegal union index for 'F64': "+ unionIndex64)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex65 = (decoder.readIndex()); + if (unionIndex65 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(65, null); + } else { + if (unionIndex65 == 1) { + Utf8 charSequence65; + Object oldString65 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(65); + if (oldString65 instanceof Utf8) { + charSequence65 = (decoder).readString(((Utf8) oldString65)); + } else { + charSequence65 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(65, charSequence65); + } else { + throw new RuntimeException(("Illegal union index for 'F65': "+ unionIndex65)); + } + } + int unionIndex66 = (decoder.readIndex()); + if (unionIndex66 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(66, null); + } else { + if (unionIndex66 == 1) { + Utf8 charSequence66; + Object oldString66 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(66); + if (oldString66 instanceof Utf8) { + charSequence66 = (decoder).readString(((Utf8) oldString66)); + } else { + charSequence66 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(66, charSequence66); + } else { + throw new RuntimeException(("Illegal union index for 'F66': "+ unionIndex66)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex67 = (decoder.readIndex()); + if (unionIndex67 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(67, null); + } else { + if (unionIndex67 == 1) { + Utf8 charSequence67; + Object oldString67 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(67); + if (oldString67 instanceof Utf8) { + charSequence67 = (decoder).readString(((Utf8) oldString67)); + } else { + charSequence67 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(67, charSequence67); + } else { + throw new RuntimeException(("Illegal union index for 'F67': "+ unionIndex67)); + } + } + int unionIndex68 = (decoder.readIndex()); + if (unionIndex68 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(68, null); + } else { + if (unionIndex68 == 1) { + Utf8 charSequence68; + Object oldString68 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(68); + if (oldString68 instanceof Utf8) { + charSequence68 = (decoder).readString(((Utf8) oldString68)); + } else { + charSequence68 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(68, charSequence68); + } else { + throw new RuntimeException(("Illegal union index for 'F68': "+ unionIndex68)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex69 = (decoder.readIndex()); + if (unionIndex69 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(69, null); + } else { + if (unionIndex69 == 1) { + Utf8 charSequence69; + Object oldString69 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(69); + if (oldString69 instanceof Utf8) { + charSequence69 = (decoder).readString(((Utf8) oldString69)); + } else { + charSequence69 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(69, charSequence69); + } else { + throw new RuntimeException(("Illegal union index for 'F69': "+ unionIndex69)); + } + } + int unionIndex70 = (decoder.readIndex()); + if (unionIndex70 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(70, null); + } else { + if (unionIndex70 == 1) { + Utf8 charSequence70; + Object oldString70 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(70); + if (oldString70 instanceof Utf8) { + charSequence70 = (decoder).readString(((Utf8) oldString70)); + } else { + charSequence70 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(70, charSequence70); + } else { + throw new RuntimeException(("Illegal union index for 'F70': "+ unionIndex70)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex71 = (decoder.readIndex()); + if (unionIndex71 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(71, null); + } else { + if (unionIndex71 == 1) { + Utf8 charSequence71; + Object oldString71 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(71); + if (oldString71 instanceof Utf8) { + charSequence71 = (decoder).readString(((Utf8) oldString71)); + } else { + charSequence71 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(71, charSequence71); + } else { + throw new RuntimeException(("Illegal union index for 'F71': "+ unionIndex71)); + } + } + int unionIndex72 = (decoder.readIndex()); + if (unionIndex72 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(72, null); + } else { + if (unionIndex72 == 1) { + Utf8 charSequence72; + Object oldString72 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(72); + if (oldString72 instanceof Utf8) { + charSequence72 = (decoder).readString(((Utf8) oldString72)); + } else { + charSequence72 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(72, charSequence72); + } else { + throw new RuntimeException(("Illegal union index for 'F72': "+ unionIndex72)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex73 = (decoder.readIndex()); + if (unionIndex73 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(73, null); + } else { + if (unionIndex73 == 1) { + Utf8 charSequence73; + Object oldString73 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(73); + if (oldString73 instanceof Utf8) { + charSequence73 = (decoder).readString(((Utf8) oldString73)); + } else { + charSequence73 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(73, charSequence73); + } else { + throw new RuntimeException(("Illegal union index for 'F73': "+ unionIndex73)); + } + } + int unionIndex74 = (decoder.readIndex()); + if (unionIndex74 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(74, null); + } else { + if (unionIndex74 == 1) { + Utf8 charSequence74; + Object oldString74 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(74); + if (oldString74 instanceof Utf8) { + charSequence74 = (decoder).readString(((Utf8) oldString74)); + } else { + charSequence74 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(74, charSequence74); + } else { + throw new RuntimeException(("Illegal union index for 'F74': "+ unionIndex74)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex75 = (decoder.readIndex()); + if (unionIndex75 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(75, null); + } else { + if (unionIndex75 == 1) { + Utf8 charSequence75; + Object oldString75 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(75); + if (oldString75 instanceof Utf8) { + charSequence75 = (decoder).readString(((Utf8) oldString75)); + } else { + charSequence75 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(75, charSequence75); + } else { + throw new RuntimeException(("Illegal union index for 'F75': "+ unionIndex75)); + } + } + int unionIndex76 = (decoder.readIndex()); + if (unionIndex76 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(76, null); + } else { + if (unionIndex76 == 1) { + Utf8 charSequence76; + Object oldString76 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(76); + if (oldString76 instanceof Utf8) { + charSequence76 = (decoder).readString(((Utf8) oldString76)); + } else { + charSequence76 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(76, charSequence76); + } else { + throw new RuntimeException(("Illegal union index for 'F76': "+ unionIndex76)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex77 = (decoder.readIndex()); + if (unionIndex77 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(77, null); + } else { + if (unionIndex77 == 1) { + Utf8 charSequence77; + Object oldString77 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(77); + if (oldString77 instanceof Utf8) { + charSequence77 = (decoder).readString(((Utf8) oldString77)); + } else { + charSequence77 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(77, charSequence77); + } else { + throw new RuntimeException(("Illegal union index for 'F77': "+ unionIndex77)); + } + } + int unionIndex78 = (decoder.readIndex()); + if (unionIndex78 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(78, null); + } else { + if (unionIndex78 == 1) { + Utf8 charSequence78; + Object oldString78 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(78); + if (oldString78 instanceof Utf8) { + charSequence78 = (decoder).readString(((Utf8) oldString78)); + } else { + charSequence78 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(78, charSequence78); + } else { + throw new RuntimeException(("Illegal union index for 'F78': "+ unionIndex78)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex79 = (decoder.readIndex()); + if (unionIndex79 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(79, null); + } else { + if (unionIndex79 == 1) { + Utf8 charSequence79; + Object oldString79 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(79); + if (oldString79 instanceof Utf8) { + charSequence79 = (decoder).readString(((Utf8) oldString79)); + } else { + charSequence79 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(79, charSequence79); + } else { + throw new RuntimeException(("Illegal union index for 'F79': "+ unionIndex79)); + } + } + int unionIndex80 = (decoder.readIndex()); + if (unionIndex80 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(80, null); + } else { + if (unionIndex80 == 1) { + Utf8 charSequence80; + Object oldString80 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(80); + if (oldString80 instanceof Utf8) { + charSequence80 = (decoder).readString(((Utf8) oldString80)); + } else { + charSequence80 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(80, charSequence80); + } else { + throw new RuntimeException(("Illegal union index for 'F80': "+ unionIndex80)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex81 = (decoder.readIndex()); + if (unionIndex81 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(81, null); + } else { + if (unionIndex81 == 1) { + Utf8 charSequence81; + Object oldString81 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(81); + if (oldString81 instanceof Utf8) { + charSequence81 = (decoder).readString(((Utf8) oldString81)); + } else { + charSequence81 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(81, charSequence81); + } else { + throw new RuntimeException(("Illegal union index for 'F81': "+ unionIndex81)); + } + } + int unionIndex82 = (decoder.readIndex()); + if (unionIndex82 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(82, null); + } else { + if (unionIndex82 == 1) { + Utf8 charSequence82; + Object oldString82 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(82); + if (oldString82 instanceof Utf8) { + charSequence82 = (decoder).readString(((Utf8) oldString82)); + } else { + charSequence82 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(82, charSequence82); + } else { + throw new RuntimeException(("Illegal union index for 'F82': "+ unionIndex82)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex83 = (decoder.readIndex()); + if (unionIndex83 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(83, null); + } else { + if (unionIndex83 == 1) { + Utf8 charSequence83; + Object oldString83 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(83); + if (oldString83 instanceof Utf8) { + charSequence83 = (decoder).readString(((Utf8) oldString83)); + } else { + charSequence83 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(83, charSequence83); + } else { + throw new RuntimeException(("Illegal union index for 'F83': "+ unionIndex83)); + } + } + int unionIndex84 = (decoder.readIndex()); + if (unionIndex84 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(84, null); + } else { + if (unionIndex84 == 1) { + Utf8 charSequence84; + Object oldString84 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(84); + if (oldString84 instanceof Utf8) { + charSequence84 = (decoder).readString(((Utf8) oldString84)); + } else { + charSequence84 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(84, charSequence84); + } else { + throw new RuntimeException(("Illegal union index for 'F84': "+ unionIndex84)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex85 = (decoder.readIndex()); + if (unionIndex85 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(85, null); + } else { + if (unionIndex85 == 1) { + Utf8 charSequence85; + Object oldString85 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(85); + if (oldString85 instanceof Utf8) { + charSequence85 = (decoder).readString(((Utf8) oldString85)); + } else { + charSequence85 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(85, charSequence85); + } else { + throw new RuntimeException(("Illegal union index for 'F85': "+ unionIndex85)); + } + } + int unionIndex86 = (decoder.readIndex()); + if (unionIndex86 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(86, null); + } else { + if (unionIndex86 == 1) { + Utf8 charSequence86; + Object oldString86 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(86); + if (oldString86 instanceof Utf8) { + charSequence86 = (decoder).readString(((Utf8) oldString86)); + } else { + charSequence86 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(86, charSequence86); + } else { + throw new RuntimeException(("Illegal union index for 'F86': "+ unionIndex86)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex87 = (decoder.readIndex()); + if (unionIndex87 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(87, null); + } else { + if (unionIndex87 == 1) { + Utf8 charSequence87; + Object oldString87 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(87); + if (oldString87 instanceof Utf8) { + charSequence87 = (decoder).readString(((Utf8) oldString87)); + } else { + charSequence87 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(87, charSequence87); + } else { + throw new RuntimeException(("Illegal union index for 'F87': "+ unionIndex87)); + } + } + int unionIndex88 = (decoder.readIndex()); + if (unionIndex88 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(88, null); + } else { + if (unionIndex88 == 1) { + Utf8 charSequence88; + Object oldString88 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(88); + if (oldString88 instanceof Utf8) { + charSequence88 = (decoder).readString(((Utf8) oldString88)); + } else { + charSequence88 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(88, charSequence88); + } else { + throw new RuntimeException(("Illegal union index for 'F88': "+ unionIndex88)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex89 = (decoder.readIndex()); + if (unionIndex89 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(89, null); + } else { + if (unionIndex89 == 1) { + Utf8 charSequence89; + Object oldString89 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(89); + if (oldString89 instanceof Utf8) { + charSequence89 = (decoder).readString(((Utf8) oldString89)); + } else { + charSequence89 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(89, charSequence89); + } else { + throw new RuntimeException(("Illegal union index for 'F89': "+ unionIndex89)); + } + } + int unionIndex90 = (decoder.readIndex()); + if (unionIndex90 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(90, null); + } else { + if (unionIndex90 == 1) { + Utf8 charSequence90; + Object oldString90 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(90); + if (oldString90 instanceof Utf8) { + charSequence90 = (decoder).readString(((Utf8) oldString90)); + } else { + charSequence90 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(90, charSequence90); + } else { + throw new RuntimeException(("Illegal union index for 'F90': "+ unionIndex90)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex91 = (decoder.readIndex()); + if (unionIndex91 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(91, null); + } else { + if (unionIndex91 == 1) { + Utf8 charSequence91; + Object oldString91 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(91); + if (oldString91 instanceof Utf8) { + charSequence91 = (decoder).readString(((Utf8) oldString91)); + } else { + charSequence91 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(91, charSequence91); + } else { + throw new RuntimeException(("Illegal union index for 'F91': "+ unionIndex91)); + } + } + int unionIndex92 = (decoder.readIndex()); + if (unionIndex92 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(92, null); + } else { + if (unionIndex92 == 1) { + Utf8 charSequence92; + Object oldString92 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(92); + if (oldString92 instanceof Utf8) { + charSequence92 = (decoder).readString(((Utf8) oldString92)); + } else { + charSequence92 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(92, charSequence92); + } else { + throw new RuntimeException(("Illegal union index for 'F92': "+ unionIndex92)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex93 = (decoder.readIndex()); + if (unionIndex93 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(93, null); + } else { + if (unionIndex93 == 1) { + Utf8 charSequence93; + Object oldString93 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(93); + if (oldString93 instanceof Utf8) { + charSequence93 = (decoder).readString(((Utf8) oldString93)); + } else { + charSequence93 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(93, charSequence93); + } else { + throw new RuntimeException(("Illegal union index for 'F93': "+ unionIndex93)); + } + } + int unionIndex94 = (decoder.readIndex()); + if (unionIndex94 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(94, null); + } else { + if (unionIndex94 == 1) { + Utf8 charSequence94; + Object oldString94 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(94); + if (oldString94 instanceof Utf8) { + charSequence94 = (decoder).readString(((Utf8) oldString94)); + } else { + charSequence94 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(94, charSequence94); + } else { + throw new RuntimeException(("Illegal union index for 'F94': "+ unionIndex94)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex95 = (decoder.readIndex()); + if (unionIndex95 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(95, null); + } else { + if (unionIndex95 == 1) { + Utf8 charSequence95; + Object oldString95 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(95); + if (oldString95 instanceof Utf8) { + charSequence95 = (decoder).readString(((Utf8) oldString95)); + } else { + charSequence95 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(95, charSequence95); + } else { + throw new RuntimeException(("Illegal union index for 'F95': "+ unionIndex95)); + } + } + int unionIndex96 = (decoder.readIndex()); + if (unionIndex96 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(96, null); + } else { + if (unionIndex96 == 1) { + Utf8 charSequence96; + Object oldString96 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(96); + if (oldString96 instanceof Utf8) { + charSequence96 = (decoder).readString(((Utf8) oldString96)); + } else { + charSequence96 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(96, charSequence96); + } else { + throw new RuntimeException(("Illegal union index for 'F96': "+ unionIndex96)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex97 = (decoder.readIndex()); + if (unionIndex97 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(97, null); + } else { + if (unionIndex97 == 1) { + Utf8 charSequence97; + Object oldString97 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(97); + if (oldString97 instanceof Utf8) { + charSequence97 = (decoder).readString(((Utf8) oldString97)); + } else { + charSequence97 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(97, charSequence97); + } else { + throw new RuntimeException(("Illegal union index for 'F97': "+ unionIndex97)); + } + } + int unionIndex98 = (decoder.readIndex()); + if (unionIndex98 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(98, null); + } else { + if (unionIndex98 == 1) { + Utf8 charSequence98; + Object oldString98 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(98); + if (oldString98 instanceof Utf8) { + charSequence98 = (decoder).readString(((Utf8) oldString98)); + } else { + charSequence98 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(98, charSequence98); + } else { + throw new RuntimeException(("Illegal union index for 'F98': "+ unionIndex98)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex99 = (decoder.readIndex()); + if (unionIndex99 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(99, null); + } else { + if (unionIndex99 == 1) { + Utf8 charSequence99; + Object oldString99 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(99); + if (oldString99 instanceof Utf8) { + charSequence99 = (decoder).readString(((Utf8) oldString99)); + } else { + charSequence99 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(99, charSequence99); + } else { + throw new RuntimeException(("Illegal union index for 'F99': "+ unionIndex99)); + } + } + int unionIndex100 = (decoder.readIndex()); + if (unionIndex100 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(100, null); + } else { + if (unionIndex100 == 1) { + Utf8 charSequence100; + Object oldString100 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(100); + if (oldString100 instanceof Utf8) { + charSequence100 = (decoder).readString(((Utf8) oldString100)); + } else { + charSequence100 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(100, charSequence100); + } else { + throw new RuntimeException(("Illegal union index for 'F100': "+ unionIndex100)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex101 = (decoder.readIndex()); + if (unionIndex101 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(101, null); + } else { + if (unionIndex101 == 1) { + Utf8 charSequence101; + Object oldString101 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(101); + if (oldString101 instanceof Utf8) { + charSequence101 = (decoder).readString(((Utf8) oldString101)); + } else { + charSequence101 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(101, charSequence101); + } else { + throw new RuntimeException(("Illegal union index for 'F101': "+ unionIndex101)); + } + } + int unionIndex102 = (decoder.readIndex()); + if (unionIndex102 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(102, null); + } else { + if (unionIndex102 == 1) { + Utf8 charSequence102; + Object oldString102 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(102); + if (oldString102 instanceof Utf8) { + charSequence102 = (decoder).readString(((Utf8) oldString102)); + } else { + charSequence102 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(102, charSequence102); + } else { + throw new RuntimeException(("Illegal union index for 'F102': "+ unionIndex102)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex103 = (decoder.readIndex()); + if (unionIndex103 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(103, null); + } else { + if (unionIndex103 == 1) { + Utf8 charSequence103; + Object oldString103 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(103); + if (oldString103 instanceof Utf8) { + charSequence103 = (decoder).readString(((Utf8) oldString103)); + } else { + charSequence103 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(103, charSequence103); + } else { + throw new RuntimeException(("Illegal union index for 'F103': "+ unionIndex103)); + } + } + int unionIndex104 = (decoder.readIndex()); + if (unionIndex104 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(104, null); + } else { + if (unionIndex104 == 1) { + Utf8 charSequence104; + Object oldString104 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(104); + if (oldString104 instanceof Utf8) { + charSequence104 = (decoder).readString(((Utf8) oldString104)); + } else { + charSequence104 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(104, charSequence104); + } else { + throw new RuntimeException(("Illegal union index for 'F104': "+ unionIndex104)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex105 = (decoder.readIndex()); + if (unionIndex105 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(105, null); + } else { + if (unionIndex105 == 1) { + Utf8 charSequence105; + Object oldString105 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(105); + if (oldString105 instanceof Utf8) { + charSequence105 = (decoder).readString(((Utf8) oldString105)); + } else { + charSequence105 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(105, charSequence105); + } else { + throw new RuntimeException(("Illegal union index for 'F105': "+ unionIndex105)); + } + } + int unionIndex106 = (decoder.readIndex()); + if (unionIndex106 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(106, null); + } else { + if (unionIndex106 == 1) { + Utf8 charSequence106; + Object oldString106 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(106); + if (oldString106 instanceof Utf8) { + charSequence106 = (decoder).readString(((Utf8) oldString106)); + } else { + charSequence106 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(106, charSequence106); + } else { + throw new RuntimeException(("Illegal union index for 'F106': "+ unionIndex106)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex107 = (decoder.readIndex()); + if (unionIndex107 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(107, null); + } else { + if (unionIndex107 == 1) { + Utf8 charSequence107; + Object oldString107 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(107); + if (oldString107 instanceof Utf8) { + charSequence107 = (decoder).readString(((Utf8) oldString107)); + } else { + charSequence107 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(107, charSequence107); + } else { + throw new RuntimeException(("Illegal union index for 'F107': "+ unionIndex107)); + } + } + int unionIndex108 = (decoder.readIndex()); + if (unionIndex108 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(108, null); + } else { + if (unionIndex108 == 1) { + Utf8 charSequence108; + Object oldString108 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(108); + if (oldString108 instanceof Utf8) { + charSequence108 = (decoder).readString(((Utf8) oldString108)); + } else { + charSequence108 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(108, charSequence108); + } else { + throw new RuntimeException(("Illegal union index for 'F108': "+ unionIndex108)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex109 = (decoder.readIndex()); + if (unionIndex109 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(109, null); + } else { + if (unionIndex109 == 1) { + Utf8 charSequence109; + Object oldString109 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(109); + if (oldString109 instanceof Utf8) { + charSequence109 = (decoder).readString(((Utf8) oldString109)); + } else { + charSequence109 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(109, charSequence109); + } else { + throw new RuntimeException(("Illegal union index for 'F109': "+ unionIndex109)); + } + } + int unionIndex110 = (decoder.readIndex()); + if (unionIndex110 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(110, null); + } else { + if (unionIndex110 == 1) { + Utf8 charSequence110; + Object oldString110 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(110); + if (oldString110 instanceof Utf8) { + charSequence110 = (decoder).readString(((Utf8) oldString110)); + } else { + charSequence110 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(110, charSequence110); + } else { + throw new RuntimeException(("Illegal union index for 'F110': "+ unionIndex110)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex111 = (decoder.readIndex()); + if (unionIndex111 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(111, null); + } else { + if (unionIndex111 == 1) { + Utf8 charSequence111; + Object oldString111 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(111); + if (oldString111 instanceof Utf8) { + charSequence111 = (decoder).readString(((Utf8) oldString111)); + } else { + charSequence111 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(111, charSequence111); + } else { + throw new RuntimeException(("Illegal union index for 'F111': "+ unionIndex111)); + } + } + int unionIndex112 = (decoder.readIndex()); + if (unionIndex112 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(112, null); + } else { + if (unionIndex112 == 1) { + Utf8 charSequence112; + Object oldString112 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(112); + if (oldString112 instanceof Utf8) { + charSequence112 = (decoder).readString(((Utf8) oldString112)); + } else { + charSequence112 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(112, charSequence112); + } else { + throw new RuntimeException(("Illegal union index for 'F112': "+ unionIndex112)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex113 = (decoder.readIndex()); + if (unionIndex113 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(113, null); + } else { + if (unionIndex113 == 1) { + Utf8 charSequence113; + Object oldString113 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(113); + if (oldString113 instanceof Utf8) { + charSequence113 = (decoder).readString(((Utf8) oldString113)); + } else { + charSequence113 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(113, charSequence113); + } else { + throw new RuntimeException(("Illegal union index for 'F113': "+ unionIndex113)); + } + } + int unionIndex114 = (decoder.readIndex()); + if (unionIndex114 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(114, null); + } else { + if (unionIndex114 == 1) { + Utf8 charSequence114; + Object oldString114 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(114); + if (oldString114 instanceof Utf8) { + charSequence114 = (decoder).readString(((Utf8) oldString114)); + } else { + charSequence114 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(114, charSequence114); + } else { + throw new RuntimeException(("Illegal union index for 'F114': "+ unionIndex114)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex115 = (decoder.readIndex()); + if (unionIndex115 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(115, null); + } else { + if (unionIndex115 == 1) { + Utf8 charSequence115; + Object oldString115 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(115); + if (oldString115 instanceof Utf8) { + charSequence115 = (decoder).readString(((Utf8) oldString115)); + } else { + charSequence115 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(115, charSequence115); + } else { + throw new RuntimeException(("Illegal union index for 'F115': "+ unionIndex115)); + } + } + int unionIndex116 = (decoder.readIndex()); + if (unionIndex116 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(116, null); + } else { + if (unionIndex116 == 1) { + Utf8 charSequence116; + Object oldString116 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(116); + if (oldString116 instanceof Utf8) { + charSequence116 = (decoder).readString(((Utf8) oldString116)); + } else { + charSequence116 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(116, charSequence116); + } else { + throw new RuntimeException(("Illegal union index for 'F116': "+ unionIndex116)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex117 = (decoder.readIndex()); + if (unionIndex117 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(117, null); + } else { + if (unionIndex117 == 1) { + Utf8 charSequence117; + Object oldString117 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(117); + if (oldString117 instanceof Utf8) { + charSequence117 = (decoder).readString(((Utf8) oldString117)); + } else { + charSequence117 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(117, charSequence117); + } else { + throw new RuntimeException(("Illegal union index for 'F117': "+ unionIndex117)); + } + } + int unionIndex118 = (decoder.readIndex()); + if (unionIndex118 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(118, null); + } else { + if (unionIndex118 == 1) { + Utf8 charSequence118; + Object oldString118 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(118); + if (oldString118 instanceof Utf8) { + charSequence118 = (decoder).readString(((Utf8) oldString118)); + } else { + charSequence118 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(118, charSequence118); + } else { + throw new RuntimeException(("Illegal union index for 'F118': "+ unionIndex118)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex119 = (decoder.readIndex()); + if (unionIndex119 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(119, null); + } else { + if (unionIndex119 == 1) { + Utf8 charSequence119; + Object oldString119 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(119); + if (oldString119 instanceof Utf8) { + charSequence119 = (decoder).readString(((Utf8) oldString119)); + } else { + charSequence119 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(119, charSequence119); + } else { + throw new RuntimeException(("Illegal union index for 'F119': "+ unionIndex119)); + } + } + int unionIndex120 = (decoder.readIndex()); + if (unionIndex120 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(120, null); + } else { + if (unionIndex120 == 1) { + Utf8 charSequence120; + Object oldString120 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(120); + if (oldString120 instanceof Utf8) { + charSequence120 = (decoder).readString(((Utf8) oldString120)); + } else { + charSequence120 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(120, charSequence120); + } else { + throw new RuntimeException(("Illegal union index for 'F120': "+ unionIndex120)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex121 = (decoder.readIndex()); + if (unionIndex121 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(121, null); + } else { + if (unionIndex121 == 1) { + Utf8 charSequence121; + Object oldString121 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(121); + if (oldString121 instanceof Utf8) { + charSequence121 = (decoder).readString(((Utf8) oldString121)); + } else { + charSequence121 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(121, charSequence121); + } else { + throw new RuntimeException(("Illegal union index for 'F121': "+ unionIndex121)); + } + } + int unionIndex122 = (decoder.readIndex()); + if (unionIndex122 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(122, null); + } else { + if (unionIndex122 == 1) { + Utf8 charSequence122; + Object oldString122 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(122); + if (oldString122 instanceof Utf8) { + charSequence122 = (decoder).readString(((Utf8) oldString122)); + } else { + charSequence122 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(122, charSequence122); + } else { + throw new RuntimeException(("Illegal union index for 'F122': "+ unionIndex122)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex123 = (decoder.readIndex()); + if (unionIndex123 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(123, null); + } else { + if (unionIndex123 == 1) { + Utf8 charSequence123; + Object oldString123 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(123); + if (oldString123 instanceof Utf8) { + charSequence123 = (decoder).readString(((Utf8) oldString123)); + } else { + charSequence123 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(123, charSequence123); + } else { + throw new RuntimeException(("Illegal union index for 'F123': "+ unionIndex123)); + } + } + int unionIndex124 = (decoder.readIndex()); + if (unionIndex124 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(124, null); + } else { + if (unionIndex124 == 1) { + Utf8 charSequence124; + Object oldString124 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(124); + if (oldString124 instanceof Utf8) { + charSequence124 = (decoder).readString(((Utf8) oldString124)); + } else { + charSequence124 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(124, charSequence124); + } else { + throw new RuntimeException(("Illegal union index for 'F124': "+ unionIndex124)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex125 = (decoder.readIndex()); + if (unionIndex125 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(125, null); + } else { + if (unionIndex125 == 1) { + Utf8 charSequence125; + Object oldString125 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(125); + if (oldString125 instanceof Utf8) { + charSequence125 = (decoder).readString(((Utf8) oldString125)); + } else { + charSequence125 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(125, charSequence125); + } else { + throw new RuntimeException(("Illegal union index for 'F125': "+ unionIndex125)); + } + } + int unionIndex126 = (decoder.readIndex()); + if (unionIndex126 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(126, null); + } else { + if (unionIndex126 == 1) { + Utf8 charSequence126; + Object oldString126 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(126); + if (oldString126 instanceof Utf8) { + charSequence126 = (decoder).readString(((Utf8) oldString126)); + } else { + charSequence126 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(126, charSequence126); + } else { + throw new RuntimeException(("Illegal union index for 'F126': "+ unionIndex126)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex127 = (decoder.readIndex()); + if (unionIndex127 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(127, null); + } else { + if (unionIndex127 == 1) { + Utf8 charSequence127; + Object oldString127 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(127); + if (oldString127 instanceof Utf8) { + charSequence127 = (decoder).readString(((Utf8) oldString127)); + } else { + charSequence127 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(127, charSequence127); + } else { + throw new RuntimeException(("Illegal union index for 'F127': "+ unionIndex127)); + } + } + int unionIndex128 = (decoder.readIndex()); + if (unionIndex128 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(128, null); + } else { + if (unionIndex128 == 1) { + Utf8 charSequence128; + Object oldString128 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(128); + if (oldString128 instanceof Utf8) { + charSequence128 = (decoder).readString(((Utf8) oldString128)); + } else { + charSequence128 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(128, charSequence128); + } else { + throw new RuntimeException(("Illegal union index for 'F128': "+ unionIndex128)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex129 = (decoder.readIndex()); + if (unionIndex129 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(129, null); + } else { + if (unionIndex129 == 1) { + Utf8 charSequence129; + Object oldString129 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(129); + if (oldString129 instanceof Utf8) { + charSequence129 = (decoder).readString(((Utf8) oldString129)); + } else { + charSequence129 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(129, charSequence129); + } else { + throw new RuntimeException(("Illegal union index for 'F129': "+ unionIndex129)); + } + } + int unionIndex130 = (decoder.readIndex()); + if (unionIndex130 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(130, null); + } else { + if (unionIndex130 == 1) { + Utf8 charSequence130; + Object oldString130 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(130); + if (oldString130 instanceof Utf8) { + charSequence130 = (decoder).readString(((Utf8) oldString130)); + } else { + charSequence130 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(130, charSequence130); + } else { + throw new RuntimeException(("Illegal union index for 'F130': "+ unionIndex130)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex131 = (decoder.readIndex()); + if (unionIndex131 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(131, null); + } else { + if (unionIndex131 == 1) { + Utf8 charSequence131; + Object oldString131 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(131); + if (oldString131 instanceof Utf8) { + charSequence131 = (decoder).readString(((Utf8) oldString131)); + } else { + charSequence131 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(131, charSequence131); + } else { + throw new RuntimeException(("Illegal union index for 'F131': "+ unionIndex131)); + } + } + int unionIndex132 = (decoder.readIndex()); + if (unionIndex132 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(132, null); + } else { + if (unionIndex132 == 1) { + Utf8 charSequence132; + Object oldString132 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(132); + if (oldString132 instanceof Utf8) { + charSequence132 = (decoder).readString(((Utf8) oldString132)); + } else { + charSequence132 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(132, charSequence132); + } else { + throw new RuntimeException(("Illegal union index for 'F132': "+ unionIndex132)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex133 = (decoder.readIndex()); + if (unionIndex133 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(133, null); + } else { + if (unionIndex133 == 1) { + Utf8 charSequence133; + Object oldString133 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(133); + if (oldString133 instanceof Utf8) { + charSequence133 = (decoder).readString(((Utf8) oldString133)); + } else { + charSequence133 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(133, charSequence133); + } else { + throw new RuntimeException(("Illegal union index for 'F133': "+ unionIndex133)); + } + } + int unionIndex134 = (decoder.readIndex()); + if (unionIndex134 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(134, null); + } else { + if (unionIndex134 == 1) { + Utf8 charSequence134; + Object oldString134 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(134); + if (oldString134 instanceof Utf8) { + charSequence134 = (decoder).readString(((Utf8) oldString134)); + } else { + charSequence134 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(134, charSequence134); + } else { + throw new RuntimeException(("Illegal union index for 'F134': "+ unionIndex134)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex135 = (decoder.readIndex()); + if (unionIndex135 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(135, null); + } else { + if (unionIndex135 == 1) { + Utf8 charSequence135; + Object oldString135 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(135); + if (oldString135 instanceof Utf8) { + charSequence135 = (decoder).readString(((Utf8) oldString135)); + } else { + charSequence135 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(135, charSequence135); + } else { + throw new RuntimeException(("Illegal union index for 'F135': "+ unionIndex135)); + } + } + int unionIndex136 = (decoder.readIndex()); + if (unionIndex136 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(136, null); + } else { + if (unionIndex136 == 1) { + Utf8 charSequence136; + Object oldString136 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(136); + if (oldString136 instanceof Utf8) { + charSequence136 = (decoder).readString(((Utf8) oldString136)); + } else { + charSequence136 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(136, charSequence136); + } else { + throw new RuntimeException(("Illegal union index for 'F136': "+ unionIndex136)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex137 = (decoder.readIndex()); + if (unionIndex137 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(137, null); + } else { + if (unionIndex137 == 1) { + Utf8 charSequence137; + Object oldString137 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(137); + if (oldString137 instanceof Utf8) { + charSequence137 = (decoder).readString(((Utf8) oldString137)); + } else { + charSequence137 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(137, charSequence137); + } else { + throw new RuntimeException(("Illegal union index for 'F137': "+ unionIndex137)); + } + } + int unionIndex138 = (decoder.readIndex()); + if (unionIndex138 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(138, null); + } else { + if (unionIndex138 == 1) { + Utf8 charSequence138; + Object oldString138 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(138); + if (oldString138 instanceof Utf8) { + charSequence138 = (decoder).readString(((Utf8) oldString138)); + } else { + charSequence138 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(138, charSequence138); + } else { + throw new RuntimeException(("Illegal union index for 'F138': "+ unionIndex138)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex139 = (decoder.readIndex()); + if (unionIndex139 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(139, null); + } else { + if (unionIndex139 == 1) { + Utf8 charSequence139; + Object oldString139 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(139); + if (oldString139 instanceof Utf8) { + charSequence139 = (decoder).readString(((Utf8) oldString139)); + } else { + charSequence139 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(139, charSequence139); + } else { + throw new RuntimeException(("Illegal union index for 'F139': "+ unionIndex139)); + } + } + int unionIndex140 = (decoder.readIndex()); + if (unionIndex140 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(140, null); + } else { + if (unionIndex140 == 1) { + Utf8 charSequence140; + Object oldString140 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(140); + if (oldString140 instanceof Utf8) { + charSequence140 = (decoder).readString(((Utf8) oldString140)); + } else { + charSequence140 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(140, charSequence140); + } else { + throw new RuntimeException(("Illegal union index for 'F140': "+ unionIndex140)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex141 = (decoder.readIndex()); + if (unionIndex141 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(141, null); + } else { + if (unionIndex141 == 1) { + Utf8 charSequence141; + Object oldString141 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(141); + if (oldString141 instanceof Utf8) { + charSequence141 = (decoder).readString(((Utf8) oldString141)); + } else { + charSequence141 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(141, charSequence141); + } else { + throw new RuntimeException(("Illegal union index for 'F141': "+ unionIndex141)); + } + } + int unionIndex142 = (decoder.readIndex()); + if (unionIndex142 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(142, null); + } else { + if (unionIndex142 == 1) { + Utf8 charSequence142; + Object oldString142 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(142); + if (oldString142 instanceof Utf8) { + charSequence142 = (decoder).readString(((Utf8) oldString142)); + } else { + charSequence142 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(142, charSequence142); + } else { + throw new RuntimeException(("Illegal union index for 'F142': "+ unionIndex142)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex143 = (decoder.readIndex()); + if (unionIndex143 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(143, null); + } else { + if (unionIndex143 == 1) { + Utf8 charSequence143; + Object oldString143 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(143); + if (oldString143 instanceof Utf8) { + charSequence143 = (decoder).readString(((Utf8) oldString143)); + } else { + charSequence143 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(143, charSequence143); + } else { + throw new RuntimeException(("Illegal union index for 'F143': "+ unionIndex143)); + } + } + int unionIndex144 = (decoder.readIndex()); + if (unionIndex144 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(144, null); + } else { + if (unionIndex144 == 1) { + Utf8 charSequence144; + Object oldString144 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(144); + if (oldString144 instanceof Utf8) { + charSequence144 = (decoder).readString(((Utf8) oldString144)); + } else { + charSequence144 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(144, charSequence144); + } else { + throw new RuntimeException(("Illegal union index for 'F144': "+ unionIndex144)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex145 = (decoder.readIndex()); + if (unionIndex145 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(145, null); + } else { + if (unionIndex145 == 1) { + Utf8 charSequence145; + Object oldString145 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(145); + if (oldString145 instanceof Utf8) { + charSequence145 = (decoder).readString(((Utf8) oldString145)); + } else { + charSequence145 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(145, charSequence145); + } else { + throw new RuntimeException(("Illegal union index for 'F145': "+ unionIndex145)); + } + } + int unionIndex146 = (decoder.readIndex()); + if (unionIndex146 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(146, null); + } else { + if (unionIndex146 == 1) { + Utf8 charSequence146; + Object oldString146 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(146); + if (oldString146 instanceof Utf8) { + charSequence146 = (decoder).readString(((Utf8) oldString146)); + } else { + charSequence146 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(146, charSequence146); + } else { + throw new RuntimeException(("Illegal union index for 'F146': "+ unionIndex146)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex147 = (decoder.readIndex()); + if (unionIndex147 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(147, null); + } else { + if (unionIndex147 == 1) { + Utf8 charSequence147; + Object oldString147 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(147); + if (oldString147 instanceof Utf8) { + charSequence147 = (decoder).readString(((Utf8) oldString147)); + } else { + charSequence147 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(147, charSequence147); + } else { + throw new RuntimeException(("Illegal union index for 'F147': "+ unionIndex147)); + } + } + int unionIndex148 = (decoder.readIndex()); + if (unionIndex148 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(148, null); + } else { + if (unionIndex148 == 1) { + Utf8 charSequence148; + Object oldString148 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(148); + if (oldString148 instanceof Utf8) { + charSequence148 = (decoder).readString(((Utf8) oldString148)); + } else { + charSequence148 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(148, charSequence148); + } else { + throw new RuntimeException(("Illegal union index for 'F148': "+ unionIndex148)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex149 = (decoder.readIndex()); + if (unionIndex149 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(149, null); + } else { + if (unionIndex149 == 1) { + Utf8 charSequence149; + Object oldString149 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(149); + if (oldString149 instanceof Utf8) { + charSequence149 = (decoder).readString(((Utf8) oldString149)); + } else { + charSequence149 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(149, charSequence149); + } else { + throw new RuntimeException(("Illegal union index for 'F149': "+ unionIndex149)); + } + } + int unionIndex150 = (decoder.readIndex()); + if (unionIndex150 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(150, null); + } else { + if (unionIndex150 == 1) { + Utf8 charSequence150; + Object oldString150 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(150); + if (oldString150 instanceof Utf8) { + charSequence150 = (decoder).readString(((Utf8) oldString150)); + } else { + charSequence150 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(150, charSequence150); + } else { + throw new RuntimeException(("Illegal union index for 'F150': "+ unionIndex150)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex151 = (decoder.readIndex()); + if (unionIndex151 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(151, null); + } else { + if (unionIndex151 == 1) { + Utf8 charSequence151; + Object oldString151 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(151); + if (oldString151 instanceof Utf8) { + charSequence151 = (decoder).readString(((Utf8) oldString151)); + } else { + charSequence151 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(151, charSequence151); + } else { + throw new RuntimeException(("Illegal union index for 'F151': "+ unionIndex151)); + } + } + int unionIndex152 = (decoder.readIndex()); + if (unionIndex152 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(152, null); + } else { + if (unionIndex152 == 1) { + Utf8 charSequence152; + Object oldString152 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(152); + if (oldString152 instanceof Utf8) { + charSequence152 = (decoder).readString(((Utf8) oldString152)); + } else { + charSequence152 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(152, charSequence152); + } else { + throw new RuntimeException(("Illegal union index for 'F152': "+ unionIndex152)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex153 = (decoder.readIndex()); + if (unionIndex153 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(153, null); + } else { + if (unionIndex153 == 1) { + Utf8 charSequence153; + Object oldString153 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(153); + if (oldString153 instanceof Utf8) { + charSequence153 = (decoder).readString(((Utf8) oldString153)); + } else { + charSequence153 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(153, charSequence153); + } else { + throw new RuntimeException(("Illegal union index for 'F153': "+ unionIndex153)); + } + } + int unionIndex154 = (decoder.readIndex()); + if (unionIndex154 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(154, null); + } else { + if (unionIndex154 == 1) { + Utf8 charSequence154; + Object oldString154 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(154); + if (oldString154 instanceof Utf8) { + charSequence154 = (decoder).readString(((Utf8) oldString154)); + } else { + charSequence154 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(154, charSequence154); + } else { + throw new RuntimeException(("Illegal union index for 'F154': "+ unionIndex154)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex155 = (decoder.readIndex()); + if (unionIndex155 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(155, null); + } else { + if (unionIndex155 == 1) { + Utf8 charSequence155; + Object oldString155 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(155); + if (oldString155 instanceof Utf8) { + charSequence155 = (decoder).readString(((Utf8) oldString155)); + } else { + charSequence155 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(155, charSequence155); + } else { + throw new RuntimeException(("Illegal union index for 'F155': "+ unionIndex155)); + } + } + int unionIndex156 = (decoder.readIndex()); + if (unionIndex156 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(156, null); + } else { + if (unionIndex156 == 1) { + Utf8 charSequence156; + Object oldString156 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(156); + if (oldString156 instanceof Utf8) { + charSequence156 = (decoder).readString(((Utf8) oldString156)); + } else { + charSequence156 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(156, charSequence156); + } else { + throw new RuntimeException(("Illegal union index for 'F156': "+ unionIndex156)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex157 = (decoder.readIndex()); + if (unionIndex157 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(157, null); + } else { + if (unionIndex157 == 1) { + Utf8 charSequence157; + Object oldString157 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(157); + if (oldString157 instanceof Utf8) { + charSequence157 = (decoder).readString(((Utf8) oldString157)); + } else { + charSequence157 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(157, charSequence157); + } else { + throw new RuntimeException(("Illegal union index for 'F157': "+ unionIndex157)); + } + } + int unionIndex158 = (decoder.readIndex()); + if (unionIndex158 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(158, null); + } else { + if (unionIndex158 == 1) { + Utf8 charSequence158; + Object oldString158 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(158); + if (oldString158 instanceof Utf8) { + charSequence158 = (decoder).readString(((Utf8) oldString158)); + } else { + charSequence158 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(158, charSequence158); + } else { + throw new RuntimeException(("Illegal union index for 'F158': "+ unionIndex158)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex159 = (decoder.readIndex()); + if (unionIndex159 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(159, null); + } else { + if (unionIndex159 == 1) { + Utf8 charSequence159; + Object oldString159 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(159); + if (oldString159 instanceof Utf8) { + charSequence159 = (decoder).readString(((Utf8) oldString159)); + } else { + charSequence159 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(159, charSequence159); + } else { + throw new RuntimeException(("Illegal union index for 'F159': "+ unionIndex159)); + } + } + int unionIndex160 = (decoder.readIndex()); + if (unionIndex160 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(160, null); + } else { + if (unionIndex160 == 1) { + Utf8 charSequence160; + Object oldString160 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(160); + if (oldString160 instanceof Utf8) { + charSequence160 = (decoder).readString(((Utf8) oldString160)); + } else { + charSequence160 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(160, charSequence160); + } else { + throw new RuntimeException(("Illegal union index for 'F160': "+ unionIndex160)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex161 = (decoder.readIndex()); + if (unionIndex161 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(161, null); + } else { + if (unionIndex161 == 1) { + Utf8 charSequence161; + Object oldString161 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(161); + if (oldString161 instanceof Utf8) { + charSequence161 = (decoder).readString(((Utf8) oldString161)); + } else { + charSequence161 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(161, charSequence161); + } else { + throw new RuntimeException(("Illegal union index for 'F161': "+ unionIndex161)); + } + } + int unionIndex162 = (decoder.readIndex()); + if (unionIndex162 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(162, null); + } else { + if (unionIndex162 == 1) { + Utf8 charSequence162; + Object oldString162 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(162); + if (oldString162 instanceof Utf8) { + charSequence162 = (decoder).readString(((Utf8) oldString162)); + } else { + charSequence162 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(162, charSequence162); + } else { + throw new RuntimeException(("Illegal union index for 'F162': "+ unionIndex162)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex163 = (decoder.readIndex()); + if (unionIndex163 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(163, null); + } else { + if (unionIndex163 == 1) { + Utf8 charSequence163; + Object oldString163 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(163); + if (oldString163 instanceof Utf8) { + charSequence163 = (decoder).readString(((Utf8) oldString163)); + } else { + charSequence163 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(163, charSequence163); + } else { + throw new RuntimeException(("Illegal union index for 'F163': "+ unionIndex163)); + } + } + int unionIndex164 = (decoder.readIndex()); + if (unionIndex164 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(164, null); + } else { + if (unionIndex164 == 1) { + Utf8 charSequence164; + Object oldString164 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(164); + if (oldString164 instanceof Utf8) { + charSequence164 = (decoder).readString(((Utf8) oldString164)); + } else { + charSequence164 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(164, charSequence164); + } else { + throw new RuntimeException(("Illegal union index for 'F164': "+ unionIndex164)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex165 = (decoder.readIndex()); + if (unionIndex165 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(165, null); + } else { + if (unionIndex165 == 1) { + Utf8 charSequence165; + Object oldString165 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(165); + if (oldString165 instanceof Utf8) { + charSequence165 = (decoder).readString(((Utf8) oldString165)); + } else { + charSequence165 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(165, charSequence165); + } else { + throw new RuntimeException(("Illegal union index for 'F165': "+ unionIndex165)); + } + } + int unionIndex166 = (decoder.readIndex()); + if (unionIndex166 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(166, null); + } else { + if (unionIndex166 == 1) { + Utf8 charSequence166; + Object oldString166 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(166); + if (oldString166 instanceof Utf8) { + charSequence166 = (decoder).readString(((Utf8) oldString166)); + } else { + charSequence166 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(166, charSequence166); + } else { + throw new RuntimeException(("Illegal union index for 'F166': "+ unionIndex166)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex167 = (decoder.readIndex()); + if (unionIndex167 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(167, null); + } else { + if (unionIndex167 == 1) { + Utf8 charSequence167; + Object oldString167 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(167); + if (oldString167 instanceof Utf8) { + charSequence167 = (decoder).readString(((Utf8) oldString167)); + } else { + charSequence167 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(167, charSequence167); + } else { + throw new RuntimeException(("Illegal union index for 'F167': "+ unionIndex167)); + } + } + int unionIndex168 = (decoder.readIndex()); + if (unionIndex168 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(168, null); + } else { + if (unionIndex168 == 1) { + Utf8 charSequence168; + Object oldString168 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(168); + if (oldString168 instanceof Utf8) { + charSequence168 = (decoder).readString(((Utf8) oldString168)); + } else { + charSequence168 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(168, charSequence168); + } else { + throw new RuntimeException(("Illegal union index for 'F168': "+ unionIndex168)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex169 = (decoder.readIndex()); + if (unionIndex169 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(169, null); + } else { + if (unionIndex169 == 1) { + Utf8 charSequence169; + Object oldString169 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(169); + if (oldString169 instanceof Utf8) { + charSequence169 = (decoder).readString(((Utf8) oldString169)); + } else { + charSequence169 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(169, charSequence169); + } else { + throw new RuntimeException(("Illegal union index for 'F169': "+ unionIndex169)); + } + } + int unionIndex170 = (decoder.readIndex()); + if (unionIndex170 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(170, null); + } else { + if (unionIndex170 == 1) { + Utf8 charSequence170; + Object oldString170 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(170); + if (oldString170 instanceof Utf8) { + charSequence170 = (decoder).readString(((Utf8) oldString170)); + } else { + charSequence170 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(170, charSequence170); + } else { + throw new RuntimeException(("Illegal union index for 'F170': "+ unionIndex170)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex171 = (decoder.readIndex()); + if (unionIndex171 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(171, null); + } else { + if (unionIndex171 == 1) { + Utf8 charSequence171; + Object oldString171 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(171); + if (oldString171 instanceof Utf8) { + charSequence171 = (decoder).readString(((Utf8) oldString171)); + } else { + charSequence171 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(171, charSequence171); + } else { + throw new RuntimeException(("Illegal union index for 'F171': "+ unionIndex171)); + } + } + int unionIndex172 = (decoder.readIndex()); + if (unionIndex172 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(172, null); + } else { + if (unionIndex172 == 1) { + Utf8 charSequence172; + Object oldString172 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(172); + if (oldString172 instanceof Utf8) { + charSequence172 = (decoder).readString(((Utf8) oldString172)); + } else { + charSequence172 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(172, charSequence172); + } else { + throw new RuntimeException(("Illegal union index for 'F172': "+ unionIndex172)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex173 = (decoder.readIndex()); + if (unionIndex173 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(173, null); + } else { + if (unionIndex173 == 1) { + Utf8 charSequence173; + Object oldString173 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(173); + if (oldString173 instanceof Utf8) { + charSequence173 = (decoder).readString(((Utf8) oldString173)); + } else { + charSequence173 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(173, charSequence173); + } else { + throw new RuntimeException(("Illegal union index for 'F173': "+ unionIndex173)); + } + } + int unionIndex174 = (decoder.readIndex()); + if (unionIndex174 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(174, null); + } else { + if (unionIndex174 == 1) { + Utf8 charSequence174; + Object oldString174 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(174); + if (oldString174 instanceof Utf8) { + charSequence174 = (decoder).readString(((Utf8) oldString174)); + } else { + charSequence174 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(174, charSequence174); + } else { + throw new RuntimeException(("Illegal union index for 'F174': "+ unionIndex174)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex175 = (decoder.readIndex()); + if (unionIndex175 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(175, null); + } else { + if (unionIndex175 == 1) { + Utf8 charSequence175; + Object oldString175 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(175); + if (oldString175 instanceof Utf8) { + charSequence175 = (decoder).readString(((Utf8) oldString175)); + } else { + charSequence175 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(175, charSequence175); + } else { + throw new RuntimeException(("Illegal union index for 'F175': "+ unionIndex175)); + } + } + int unionIndex176 = (decoder.readIndex()); + if (unionIndex176 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(176, null); + } else { + if (unionIndex176 == 1) { + Utf8 charSequence176; + Object oldString176 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(176); + if (oldString176 instanceof Utf8) { + charSequence176 = (decoder).readString(((Utf8) oldString176)); + } else { + charSequence176 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(176, charSequence176); + } else { + throw new RuntimeException(("Illegal union index for 'F176': "+ unionIndex176)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex177 = (decoder.readIndex()); + if (unionIndex177 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(177, null); + } else { + if (unionIndex177 == 1) { + Utf8 charSequence177; + Object oldString177 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(177); + if (oldString177 instanceof Utf8) { + charSequence177 = (decoder).readString(((Utf8) oldString177)); + } else { + charSequence177 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(177, charSequence177); + } else { + throw new RuntimeException(("Illegal union index for 'F177': "+ unionIndex177)); + } + } + int unionIndex178 = (decoder.readIndex()); + if (unionIndex178 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(178, null); + } else { + if (unionIndex178 == 1) { + Utf8 charSequence178; + Object oldString178 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(178); + if (oldString178 instanceof Utf8) { + charSequence178 = (decoder).readString(((Utf8) oldString178)); + } else { + charSequence178 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(178, charSequence178); + } else { + throw new RuntimeException(("Illegal union index for 'F178': "+ unionIndex178)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex179 = (decoder.readIndex()); + if (unionIndex179 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(179, null); + } else { + if (unionIndex179 == 1) { + Utf8 charSequence179; + Object oldString179 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(179); + if (oldString179 instanceof Utf8) { + charSequence179 = (decoder).readString(((Utf8) oldString179)); + } else { + charSequence179 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(179, charSequence179); + } else { + throw new RuntimeException(("Illegal union index for 'F179': "+ unionIndex179)); + } + } + int unionIndex180 = (decoder.readIndex()); + if (unionIndex180 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(180, null); + } else { + if (unionIndex180 == 1) { + Utf8 charSequence180; + Object oldString180 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(180); + if (oldString180 instanceof Utf8) { + charSequence180 = (decoder).readString(((Utf8) oldString180)); + } else { + charSequence180 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(180, charSequence180); + } else { + throw new RuntimeException(("Illegal union index for 'F180': "+ unionIndex180)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex181 = (decoder.readIndex()); + if (unionIndex181 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(181, null); + } else { + if (unionIndex181 == 1) { + Utf8 charSequence181; + Object oldString181 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(181); + if (oldString181 instanceof Utf8) { + charSequence181 = (decoder).readString(((Utf8) oldString181)); + } else { + charSequence181 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(181, charSequence181); + } else { + throw new RuntimeException(("Illegal union index for 'F181': "+ unionIndex181)); + } + } + int unionIndex182 = (decoder.readIndex()); + if (unionIndex182 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(182, null); + } else { + if (unionIndex182 == 1) { + Utf8 charSequence182; + Object oldString182 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(182); + if (oldString182 instanceof Utf8) { + charSequence182 = (decoder).readString(((Utf8) oldString182)); + } else { + charSequence182 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(182, charSequence182); + } else { + throw new RuntimeException(("Illegal union index for 'F182': "+ unionIndex182)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex183 = (decoder.readIndex()); + if (unionIndex183 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(183, null); + } else { + if (unionIndex183 == 1) { + Utf8 charSequence183; + Object oldString183 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(183); + if (oldString183 instanceof Utf8) { + charSequence183 = (decoder).readString(((Utf8) oldString183)); + } else { + charSequence183 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(183, charSequence183); + } else { + throw new RuntimeException(("Illegal union index for 'F183': "+ unionIndex183)); + } + } + int unionIndex184 = (decoder.readIndex()); + if (unionIndex184 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(184, null); + } else { + if (unionIndex184 == 1) { + Utf8 charSequence184; + Object oldString184 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(184); + if (oldString184 instanceof Utf8) { + charSequence184 = (decoder).readString(((Utf8) oldString184)); + } else { + charSequence184 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(184, charSequence184); + } else { + throw new RuntimeException(("Illegal union index for 'F184': "+ unionIndex184)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex185 = (decoder.readIndex()); + if (unionIndex185 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(185, null); + } else { + if (unionIndex185 == 1) { + Utf8 charSequence185; + Object oldString185 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(185); + if (oldString185 instanceof Utf8) { + charSequence185 = (decoder).readString(((Utf8) oldString185)); + } else { + charSequence185 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(185, charSequence185); + } else { + throw new RuntimeException(("Illegal union index for 'F185': "+ unionIndex185)); + } + } + int unionIndex186 = (decoder.readIndex()); + if (unionIndex186 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(186, null); + } else { + if (unionIndex186 == 1) { + Utf8 charSequence186; + Object oldString186 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(186); + if (oldString186 instanceof Utf8) { + charSequence186 = (decoder).readString(((Utf8) oldString186)); + } else { + charSequence186 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(186, charSequence186); + } else { + throw new RuntimeException(("Illegal union index for 'F186': "+ unionIndex186)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex187 = (decoder.readIndex()); + if (unionIndex187 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(187, null); + } else { + if (unionIndex187 == 1) { + Utf8 charSequence187; + Object oldString187 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(187); + if (oldString187 instanceof Utf8) { + charSequence187 = (decoder).readString(((Utf8) oldString187)); + } else { + charSequence187 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(187, charSequence187); + } else { + throw new RuntimeException(("Illegal union index for 'F187': "+ unionIndex187)); + } + } + int unionIndex188 = (decoder.readIndex()); + if (unionIndex188 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(188, null); + } else { + if (unionIndex188 == 1) { + Utf8 charSequence188; + Object oldString188 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(188); + if (oldString188 instanceof Utf8) { + charSequence188 = (decoder).readString(((Utf8) oldString188)); + } else { + charSequence188 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(188, charSequence188); + } else { + throw new RuntimeException(("Illegal union index for 'F188': "+ unionIndex188)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex189 = (decoder.readIndex()); + if (unionIndex189 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(189, null); + } else { + if (unionIndex189 == 1) { + Utf8 charSequence189; + Object oldString189 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(189); + if (oldString189 instanceof Utf8) { + charSequence189 = (decoder).readString(((Utf8) oldString189)); + } else { + charSequence189 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(189, charSequence189); + } else { + throw new RuntimeException(("Illegal union index for 'F189': "+ unionIndex189)); + } + } + int unionIndex190 = (decoder.readIndex()); + if (unionIndex190 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(190, null); + } else { + if (unionIndex190 == 1) { + Utf8 charSequence190; + Object oldString190 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(190); + if (oldString190 instanceof Utf8) { + charSequence190 = (decoder).readString(((Utf8) oldString190)); + } else { + charSequence190 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(190, charSequence190); + } else { + throw new RuntimeException(("Illegal union index for 'F190': "+ unionIndex190)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex191 = (decoder.readIndex()); + if (unionIndex191 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(191, null); + } else { + if (unionIndex191 == 1) { + Utf8 charSequence191; + Object oldString191 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(191); + if (oldString191 instanceof Utf8) { + charSequence191 = (decoder).readString(((Utf8) oldString191)); + } else { + charSequence191 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(191, charSequence191); + } else { + throw new RuntimeException(("Illegal union index for 'F191': "+ unionIndex191)); + } + } + int unionIndex192 = (decoder.readIndex()); + if (unionIndex192 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(192, null); + } else { + if (unionIndex192 == 1) { + Utf8 charSequence192; + Object oldString192 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(192); + if (oldString192 instanceof Utf8) { + charSequence192 = (decoder).readString(((Utf8) oldString192)); + } else { + charSequence192 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(192, charSequence192); + } else { + throw new RuntimeException(("Illegal union index for 'F192': "+ unionIndex192)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex193 = (decoder.readIndex()); + if (unionIndex193 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(193, null); + } else { + if (unionIndex193 == 1) { + Utf8 charSequence193; + Object oldString193 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(193); + if (oldString193 instanceof Utf8) { + charSequence193 = (decoder).readString(((Utf8) oldString193)); + } else { + charSequence193 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(193, charSequence193); + } else { + throw new RuntimeException(("Illegal union index for 'F193': "+ unionIndex193)); + } + } + int unionIndex194 = (decoder.readIndex()); + if (unionIndex194 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(194, null); + } else { + if (unionIndex194 == 1) { + Utf8 charSequence194; + Object oldString194 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(194); + if (oldString194 instanceof Utf8) { + charSequence194 = (decoder).readString(((Utf8) oldString194)); + } else { + charSequence194 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(194, charSequence194); + } else { + throw new RuntimeException(("Illegal union index for 'F194': "+ unionIndex194)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex195 = (decoder.readIndex()); + if (unionIndex195 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(195, null); + } else { + if (unionIndex195 == 1) { + Utf8 charSequence195; + Object oldString195 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(195); + if (oldString195 instanceof Utf8) { + charSequence195 = (decoder).readString(((Utf8) oldString195)); + } else { + charSequence195 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(195, charSequence195); + } else { + throw new RuntimeException(("Illegal union index for 'F195': "+ unionIndex195)); + } + } + int unionIndex196 = (decoder.readIndex()); + if (unionIndex196 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(196, null); + } else { + if (unionIndex196 == 1) { + Utf8 charSequence196; + Object oldString196 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(196); + if (oldString196 instanceof Utf8) { + charSequence196 = (decoder).readString(((Utf8) oldString196)); + } else { + charSequence196 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(196, charSequence196); + } else { + throw new RuntimeException(("Illegal union index for 'F196': "+ unionIndex196)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex197 = (decoder.readIndex()); + if (unionIndex197 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(197, null); + } else { + if (unionIndex197 == 1) { + Utf8 charSequence197; + Object oldString197 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(197); + if (oldString197 instanceof Utf8) { + charSequence197 = (decoder).readString(((Utf8) oldString197)); + } else { + charSequence197 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(197, charSequence197); + } else { + throw new RuntimeException(("Illegal union index for 'F197': "+ unionIndex197)); + } + } + int unionIndex198 = (decoder.readIndex()); + if (unionIndex198 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(198, null); + } else { + if (unionIndex198 == 1) { + Utf8 charSequence198; + Object oldString198 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(198); + if (oldString198 instanceof Utf8) { + charSequence198 = (decoder).readString(((Utf8) oldString198)); + } else { + charSequence198 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(198, charSequence198); + } else { + throw new RuntimeException(("Illegal union index for 'F198': "+ unionIndex198)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex199 = (decoder.readIndex()); + if (unionIndex199 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(199, null); + } else { + if (unionIndex199 == 1) { + Utf8 charSequence199; + Object oldString199 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(199); + if (oldString199 instanceof Utf8) { + charSequence199 = (decoder).readString(((Utf8) oldString199)); + } else { + charSequence199 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(199, charSequence199); + } else { + throw new RuntimeException(("Illegal union index for 'F199': "+ unionIndex199)); + } + } + int unionIndex200 = (decoder.readIndex()); + if (unionIndex200 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(200, null); + } else { + if (unionIndex200 == 1) { + Utf8 charSequence200; + Object oldString200 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(200); + if (oldString200 instanceof Utf8) { + charSequence200 = (decoder).readString(((Utf8) oldString200)); + } else { + charSequence200 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(200, charSequence200); + } else { + throw new RuntimeException(("Illegal union index for 'F200': "+ unionIndex200)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex201 = (decoder.readIndex()); + if (unionIndex201 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(201, null); + } else { + if (unionIndex201 == 1) { + Utf8 charSequence201; + Object oldString201 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(201); + if (oldString201 instanceof Utf8) { + charSequence201 = (decoder).readString(((Utf8) oldString201)); + } else { + charSequence201 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(201, charSequence201); + } else { + throw new RuntimeException(("Illegal union index for 'F201': "+ unionIndex201)); + } + } + int unionIndex202 = (decoder.readIndex()); + if (unionIndex202 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(202, null); + } else { + if (unionIndex202 == 1) { + Utf8 charSequence202; + Object oldString202 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(202); + if (oldString202 instanceof Utf8) { + charSequence202 = (decoder).readString(((Utf8) oldString202)); + } else { + charSequence202 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(202, charSequence202); + } else { + throw new RuntimeException(("Illegal union index for 'F202': "+ unionIndex202)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex203 = (decoder.readIndex()); + if (unionIndex203 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(203, null); + } else { + if (unionIndex203 == 1) { + Utf8 charSequence203; + Object oldString203 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(203); + if (oldString203 instanceof Utf8) { + charSequence203 = (decoder).readString(((Utf8) oldString203)); + } else { + charSequence203 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(203, charSequence203); + } else { + throw new RuntimeException(("Illegal union index for 'F203': "+ unionIndex203)); + } + } + int unionIndex204 = (decoder.readIndex()); + if (unionIndex204 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(204, null); + } else { + if (unionIndex204 == 1) { + Utf8 charSequence204; + Object oldString204 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(204); + if (oldString204 instanceof Utf8) { + charSequence204 = (decoder).readString(((Utf8) oldString204)); + } else { + charSequence204 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(204, charSequence204); + } else { + throw new RuntimeException(("Illegal union index for 'F204': "+ unionIndex204)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex205 = (decoder.readIndex()); + if (unionIndex205 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(205, null); + } else { + if (unionIndex205 == 1) { + Utf8 charSequence205; + Object oldString205 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(205); + if (oldString205 instanceof Utf8) { + charSequence205 = (decoder).readString(((Utf8) oldString205)); + } else { + charSequence205 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(205, charSequence205); + } else { + throw new RuntimeException(("Illegal union index for 'F205': "+ unionIndex205)); + } + } + int unionIndex206 = (decoder.readIndex()); + if (unionIndex206 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(206, null); + } else { + if (unionIndex206 == 1) { + Utf8 charSequence206; + Object oldString206 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(206); + if (oldString206 instanceof Utf8) { + charSequence206 = (decoder).readString(((Utf8) oldString206)); + } else { + charSequence206 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(206, charSequence206); + } else { + throw new RuntimeException(("Illegal union index for 'F206': "+ unionIndex206)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex207 = (decoder.readIndex()); + if (unionIndex207 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(207, null); + } else { + if (unionIndex207 == 1) { + Utf8 charSequence207; + Object oldString207 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(207); + if (oldString207 instanceof Utf8) { + charSequence207 = (decoder).readString(((Utf8) oldString207)); + } else { + charSequence207 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(207, charSequence207); + } else { + throw new RuntimeException(("Illegal union index for 'F207': "+ unionIndex207)); + } + } + int unionIndex208 = (decoder.readIndex()); + if (unionIndex208 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(208, null); + } else { + if (unionIndex208 == 1) { + Utf8 charSequence208; + Object oldString208 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(208); + if (oldString208 instanceof Utf8) { + charSequence208 = (decoder).readString(((Utf8) oldString208)); + } else { + charSequence208 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(208, charSequence208); + } else { + throw new RuntimeException(("Illegal union index for 'F208': "+ unionIndex208)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex209 = (decoder.readIndex()); + if (unionIndex209 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(209, null); + } else { + if (unionIndex209 == 1) { + Utf8 charSequence209; + Object oldString209 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(209); + if (oldString209 instanceof Utf8) { + charSequence209 = (decoder).readString(((Utf8) oldString209)); + } else { + charSequence209 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(209, charSequence209); + } else { + throw new RuntimeException(("Illegal union index for 'F209': "+ unionIndex209)); + } + } + int unionIndex210 = (decoder.readIndex()); + if (unionIndex210 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(210, null); + } else { + if (unionIndex210 == 1) { + Utf8 charSequence210; + Object oldString210 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(210); + if (oldString210 instanceof Utf8) { + charSequence210 = (decoder).readString(((Utf8) oldString210)); + } else { + charSequence210 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(210, charSequence210); + } else { + throw new RuntimeException(("Illegal union index for 'F210': "+ unionIndex210)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex211 = (decoder.readIndex()); + if (unionIndex211 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(211, null); + } else { + if (unionIndex211 == 1) { + Utf8 charSequence211; + Object oldString211 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(211); + if (oldString211 instanceof Utf8) { + charSequence211 = (decoder).readString(((Utf8) oldString211)); + } else { + charSequence211 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(211, charSequence211); + } else { + throw new RuntimeException(("Illegal union index for 'F211': "+ unionIndex211)); + } + } + int unionIndex212 = (decoder.readIndex()); + if (unionIndex212 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(212, null); + } else { + if (unionIndex212 == 1) { + Utf8 charSequence212; + Object oldString212 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(212); + if (oldString212 instanceof Utf8) { + charSequence212 = (decoder).readString(((Utf8) oldString212)); + } else { + charSequence212 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(212, charSequence212); + } else { + throw new RuntimeException(("Illegal union index for 'F212': "+ unionIndex212)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex213 = (decoder.readIndex()); + if (unionIndex213 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(213, null); + } else { + if (unionIndex213 == 1) { + Utf8 charSequence213; + Object oldString213 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(213); + if (oldString213 instanceof Utf8) { + charSequence213 = (decoder).readString(((Utf8) oldString213)); + } else { + charSequence213 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(213, charSequence213); + } else { + throw new RuntimeException(("Illegal union index for 'F213': "+ unionIndex213)); + } + } + int unionIndex214 = (decoder.readIndex()); + if (unionIndex214 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(214, null); + } else { + if (unionIndex214 == 1) { + Utf8 charSequence214; + Object oldString214 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(214); + if (oldString214 instanceof Utf8) { + charSequence214 = (decoder).readString(((Utf8) oldString214)); + } else { + charSequence214 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(214, charSequence214); + } else { + throw new RuntimeException(("Illegal union index for 'F214': "+ unionIndex214)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex215 = (decoder.readIndex()); + if (unionIndex215 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(215, null); + } else { + if (unionIndex215 == 1) { + Utf8 charSequence215; + Object oldString215 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(215); + if (oldString215 instanceof Utf8) { + charSequence215 = (decoder).readString(((Utf8) oldString215)); + } else { + charSequence215 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(215, charSequence215); + } else { + throw new RuntimeException(("Illegal union index for 'F215': "+ unionIndex215)); + } + } + int unionIndex216 = (decoder.readIndex()); + if (unionIndex216 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(216, null); + } else { + if (unionIndex216 == 1) { + Utf8 charSequence216; + Object oldString216 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(216); + if (oldString216 instanceof Utf8) { + charSequence216 = (decoder).readString(((Utf8) oldString216)); + } else { + charSequence216 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(216, charSequence216); + } else { + throw new RuntimeException(("Illegal union index for 'F216': "+ unionIndex216)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex217 = (decoder.readIndex()); + if (unionIndex217 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(217, null); + } else { + if (unionIndex217 == 1) { + Utf8 charSequence217; + Object oldString217 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(217); + if (oldString217 instanceof Utf8) { + charSequence217 = (decoder).readString(((Utf8) oldString217)); + } else { + charSequence217 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(217, charSequence217); + } else { + throw new RuntimeException(("Illegal union index for 'F217': "+ unionIndex217)); + } + } + int unionIndex218 = (decoder.readIndex()); + if (unionIndex218 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(218, null); + } else { + if (unionIndex218 == 1) { + Utf8 charSequence218; + Object oldString218 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(218); + if (oldString218 instanceof Utf8) { + charSequence218 = (decoder).readString(((Utf8) oldString218)); + } else { + charSequence218 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(218, charSequence218); + } else { + throw new RuntimeException(("Illegal union index for 'F218': "+ unionIndex218)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex219 = (decoder.readIndex()); + if (unionIndex219 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(219, null); + } else { + if (unionIndex219 == 1) { + Utf8 charSequence219; + Object oldString219 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(219); + if (oldString219 instanceof Utf8) { + charSequence219 = (decoder).readString(((Utf8) oldString219)); + } else { + charSequence219 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(219, charSequence219); + } else { + throw new RuntimeException(("Illegal union index for 'F219': "+ unionIndex219)); + } + } + int unionIndex220 = (decoder.readIndex()); + if (unionIndex220 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(220, null); + } else { + if (unionIndex220 == 1) { + Utf8 charSequence220; + Object oldString220 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(220); + if (oldString220 instanceof Utf8) { + charSequence220 = (decoder).readString(((Utf8) oldString220)); + } else { + charSequence220 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(220, charSequence220); + } else { + throw new RuntimeException(("Illegal union index for 'F220': "+ unionIndex220)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex221 = (decoder.readIndex()); + if (unionIndex221 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(221, null); + } else { + if (unionIndex221 == 1) { + Utf8 charSequence221; + Object oldString221 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(221); + if (oldString221 instanceof Utf8) { + charSequence221 = (decoder).readString(((Utf8) oldString221)); + } else { + charSequence221 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(221, charSequence221); + } else { + throw new RuntimeException(("Illegal union index for 'F221': "+ unionIndex221)); + } + } + int unionIndex222 = (decoder.readIndex()); + if (unionIndex222 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(222, null); + } else { + if (unionIndex222 == 1) { + Utf8 charSequence222; + Object oldString222 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(222); + if (oldString222 instanceof Utf8) { + charSequence222 = (decoder).readString(((Utf8) oldString222)); + } else { + charSequence222 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(222, charSequence222); + } else { + throw new RuntimeException(("Illegal union index for 'F222': "+ unionIndex222)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex223 = (decoder.readIndex()); + if (unionIndex223 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(223, null); + } else { + if (unionIndex223 == 1) { + Utf8 charSequence223; + Object oldString223 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(223); + if (oldString223 instanceof Utf8) { + charSequence223 = (decoder).readString(((Utf8) oldString223)); + } else { + charSequence223 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(223, charSequence223); + } else { + throw new RuntimeException(("Illegal union index for 'F223': "+ unionIndex223)); + } + } + int unionIndex224 = (decoder.readIndex()); + if (unionIndex224 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(224, null); + } else { + if (unionIndex224 == 1) { + Utf8 charSequence224; + Object oldString224 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(224); + if (oldString224 instanceof Utf8) { + charSequence224 = (decoder).readString(((Utf8) oldString224)); + } else { + charSequence224 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(224, charSequence224); + } else { + throw new RuntimeException(("Illegal union index for 'F224': "+ unionIndex224)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex225 = (decoder.readIndex()); + if (unionIndex225 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(225, null); + } else { + if (unionIndex225 == 1) { + Utf8 charSequence225; + Object oldString225 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(225); + if (oldString225 instanceof Utf8) { + charSequence225 = (decoder).readString(((Utf8) oldString225)); + } else { + charSequence225 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(225, charSequence225); + } else { + throw new RuntimeException(("Illegal union index for 'F225': "+ unionIndex225)); + } + } + int unionIndex226 = (decoder.readIndex()); + if (unionIndex226 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(226, null); + } else { + if (unionIndex226 == 1) { + Utf8 charSequence226; + Object oldString226 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(226); + if (oldString226 instanceof Utf8) { + charSequence226 = (decoder).readString(((Utf8) oldString226)); + } else { + charSequence226 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(226, charSequence226); + } else { + throw new RuntimeException(("Illegal union index for 'F226': "+ unionIndex226)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex227 = (decoder.readIndex()); + if (unionIndex227 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(227, null); + } else { + if (unionIndex227 == 1) { + Utf8 charSequence227; + Object oldString227 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(227); + if (oldString227 instanceof Utf8) { + charSequence227 = (decoder).readString(((Utf8) oldString227)); + } else { + charSequence227 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(227, charSequence227); + } else { + throw new RuntimeException(("Illegal union index for 'F227': "+ unionIndex227)); + } + } + int unionIndex228 = (decoder.readIndex()); + if (unionIndex228 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(228, null); + } else { + if (unionIndex228 == 1) { + Utf8 charSequence228; + Object oldString228 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(228); + if (oldString228 instanceof Utf8) { + charSequence228 = (decoder).readString(((Utf8) oldString228)); + } else { + charSequence228 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(228, charSequence228); + } else { + throw new RuntimeException(("Illegal union index for 'F228': "+ unionIndex228)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex229 = (decoder.readIndex()); + if (unionIndex229 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(229, null); + } else { + if (unionIndex229 == 1) { + Utf8 charSequence229; + Object oldString229 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(229); + if (oldString229 instanceof Utf8) { + charSequence229 = (decoder).readString(((Utf8) oldString229)); + } else { + charSequence229 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(229, charSequence229); + } else { + throw new RuntimeException(("Illegal union index for 'F229': "+ unionIndex229)); + } + } + int unionIndex230 = (decoder.readIndex()); + if (unionIndex230 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(230, null); + } else { + if (unionIndex230 == 1) { + Utf8 charSequence230; + Object oldString230 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(230); + if (oldString230 instanceof Utf8) { + charSequence230 = (decoder).readString(((Utf8) oldString230)); + } else { + charSequence230 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(230, charSequence230); + } else { + throw new RuntimeException(("Illegal union index for 'F230': "+ unionIndex230)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex231 = (decoder.readIndex()); + if (unionIndex231 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(231, null); + } else { + if (unionIndex231 == 1) { + Utf8 charSequence231; + Object oldString231 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(231); + if (oldString231 instanceof Utf8) { + charSequence231 = (decoder).readString(((Utf8) oldString231)); + } else { + charSequence231 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(231, charSequence231); + } else { + throw new RuntimeException(("Illegal union index for 'F231': "+ unionIndex231)); + } + } + int unionIndex232 = (decoder.readIndex()); + if (unionIndex232 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(232, null); + } else { + if (unionIndex232 == 1) { + Utf8 charSequence232; + Object oldString232 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(232); + if (oldString232 instanceof Utf8) { + charSequence232 = (decoder).readString(((Utf8) oldString232)); + } else { + charSequence232 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(232, charSequence232); + } else { + throw new RuntimeException(("Illegal union index for 'F232': "+ unionIndex232)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex233 = (decoder.readIndex()); + if (unionIndex233 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(233, null); + } else { + if (unionIndex233 == 1) { + Utf8 charSequence233; + Object oldString233 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(233); + if (oldString233 instanceof Utf8) { + charSequence233 = (decoder).readString(((Utf8) oldString233)); + } else { + charSequence233 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(233, charSequence233); + } else { + throw new RuntimeException(("Illegal union index for 'F233': "+ unionIndex233)); + } + } + int unionIndex234 = (decoder.readIndex()); + if (unionIndex234 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(234, null); + } else { + if (unionIndex234 == 1) { + Utf8 charSequence234; + Object oldString234 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(234); + if (oldString234 instanceof Utf8) { + charSequence234 = (decoder).readString(((Utf8) oldString234)); + } else { + charSequence234 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(234, charSequence234); + } else { + throw new RuntimeException(("Illegal union index for 'F234': "+ unionIndex234)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex235 = (decoder.readIndex()); + if (unionIndex235 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(235, null); + } else { + if (unionIndex235 == 1) { + Utf8 charSequence235; + Object oldString235 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(235); + if (oldString235 instanceof Utf8) { + charSequence235 = (decoder).readString(((Utf8) oldString235)); + } else { + charSequence235 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(235, charSequence235); + } else { + throw new RuntimeException(("Illegal union index for 'F235': "+ unionIndex235)); + } + } + int unionIndex236 = (decoder.readIndex()); + if (unionIndex236 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(236, null); + } else { + if (unionIndex236 == 1) { + Utf8 charSequence236; + Object oldString236 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(236); + if (oldString236 instanceof Utf8) { + charSequence236 = (decoder).readString(((Utf8) oldString236)); + } else { + charSequence236 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(236, charSequence236); + } else { + throw new RuntimeException(("Illegal union index for 'F236': "+ unionIndex236)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex237 = (decoder.readIndex()); + if (unionIndex237 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(237, null); + } else { + if (unionIndex237 == 1) { + Utf8 charSequence237; + Object oldString237 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(237); + if (oldString237 instanceof Utf8) { + charSequence237 = (decoder).readString(((Utf8) oldString237)); + } else { + charSequence237 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(237, charSequence237); + } else { + throw new RuntimeException(("Illegal union index for 'F237': "+ unionIndex237)); + } + } + int unionIndex238 = (decoder.readIndex()); + if (unionIndex238 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(238, null); + } else { + if (unionIndex238 == 1) { + Utf8 charSequence238; + Object oldString238 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(238); + if (oldString238 instanceof Utf8) { + charSequence238 = (decoder).readString(((Utf8) oldString238)); + } else { + charSequence238 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(238, charSequence238); + } else { + throw new RuntimeException(("Illegal union index for 'F238': "+ unionIndex238)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex239 = (decoder.readIndex()); + if (unionIndex239 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(239, null); + } else { + if (unionIndex239 == 1) { + Utf8 charSequence239; + Object oldString239 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(239); + if (oldString239 instanceof Utf8) { + charSequence239 = (decoder).readString(((Utf8) oldString239)); + } else { + charSequence239 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(239, charSequence239); + } else { + throw new RuntimeException(("Illegal union index for 'F239': "+ unionIndex239)); + } + } + int unionIndex240 = (decoder.readIndex()); + if (unionIndex240 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(240, null); + } else { + if (unionIndex240 == 1) { + Utf8 charSequence240; + Object oldString240 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(240); + if (oldString240 instanceof Utf8) { + charSequence240 = (decoder).readString(((Utf8) oldString240)); + } else { + charSequence240 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(240, charSequence240); + } else { + throw new RuntimeException(("Illegal union index for 'F240': "+ unionIndex240)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex241 = (decoder.readIndex()); + if (unionIndex241 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(241, null); + } else { + if (unionIndex241 == 1) { + Utf8 charSequence241; + Object oldString241 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(241); + if (oldString241 instanceof Utf8) { + charSequence241 = (decoder).readString(((Utf8) oldString241)); + } else { + charSequence241 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(241, charSequence241); + } else { + throw new RuntimeException(("Illegal union index for 'F241': "+ unionIndex241)); + } + } + int unionIndex242 = (decoder.readIndex()); + if (unionIndex242 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(242, null); + } else { + if (unionIndex242 == 1) { + Utf8 charSequence242; + Object oldString242 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(242); + if (oldString242 instanceof Utf8) { + charSequence242 = (decoder).readString(((Utf8) oldString242)); + } else { + charSequence242 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(242, charSequence242); + } else { + throw new RuntimeException(("Illegal union index for 'F242': "+ unionIndex242)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex243 = (decoder.readIndex()); + if (unionIndex243 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(243, null); + } else { + if (unionIndex243 == 1) { + Utf8 charSequence243; + Object oldString243 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(243); + if (oldString243 instanceof Utf8) { + charSequence243 = (decoder).readString(((Utf8) oldString243)); + } else { + charSequence243 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(243, charSequence243); + } else { + throw new RuntimeException(("Illegal union index for 'F243': "+ unionIndex243)); + } + } + int unionIndex244 = (decoder.readIndex()); + if (unionIndex244 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(244, null); + } else { + if (unionIndex244 == 1) { + Utf8 charSequence244; + Object oldString244 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(244); + if (oldString244 instanceof Utf8) { + charSequence244 = (decoder).readString(((Utf8) oldString244)); + } else { + charSequence244 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(244, charSequence244); + } else { + throw new RuntimeException(("Illegal union index for 'F244': "+ unionIndex244)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex245 = (decoder.readIndex()); + if (unionIndex245 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(245, null); + } else { + if (unionIndex245 == 1) { + Utf8 charSequence245; + Object oldString245 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(245); + if (oldString245 instanceof Utf8) { + charSequence245 = (decoder).readString(((Utf8) oldString245)); + } else { + charSequence245 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(245, charSequence245); + } else { + throw new RuntimeException(("Illegal union index for 'F245': "+ unionIndex245)); + } + } + int unionIndex246 = (decoder.readIndex()); + if (unionIndex246 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(246, null); + } else { + if (unionIndex246 == 1) { + Utf8 charSequence246; + Object oldString246 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(246); + if (oldString246 instanceof Utf8) { + charSequence246 = (decoder).readString(((Utf8) oldString246)); + } else { + charSequence246 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(246, charSequence246); + } else { + throw new RuntimeException(("Illegal union index for 'F246': "+ unionIndex246)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex247 = (decoder.readIndex()); + if (unionIndex247 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(247, null); + } else { + if (unionIndex247 == 1) { + Utf8 charSequence247; + Object oldString247 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(247); + if (oldString247 instanceof Utf8) { + charSequence247 = (decoder).readString(((Utf8) oldString247)); + } else { + charSequence247 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(247, charSequence247); + } else { + throw new RuntimeException(("Illegal union index for 'F247': "+ unionIndex247)); + } + } + int unionIndex248 = (decoder.readIndex()); + if (unionIndex248 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(248, null); + } else { + if (unionIndex248 == 1) { + Utf8 charSequence248; + Object oldString248 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(248); + if (oldString248 instanceof Utf8) { + charSequence248 = (decoder).readString(((Utf8) oldString248)); + } else { + charSequence248 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(248, charSequence248); + } else { + throw new RuntimeException(("Illegal union index for 'F248': "+ unionIndex248)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex249 = (decoder.readIndex()); + if (unionIndex249 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(249, null); + } else { + if (unionIndex249 == 1) { + Utf8 charSequence249; + Object oldString249 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(249); + if (oldString249 instanceof Utf8) { + charSequence249 = (decoder).readString(((Utf8) oldString249)); + } else { + charSequence249 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(249, charSequence249); + } else { + throw new RuntimeException(("Illegal union index for 'F249': "+ unionIndex249)); + } + } + int unionIndex250 = (decoder.readIndex()); + if (unionIndex250 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(250, null); + } else { + if (unionIndex250 == 1) { + Utf8 charSequence250; + Object oldString250 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(250); + if (oldString250 instanceof Utf8) { + charSequence250 = (decoder).readString(((Utf8) oldString250)); + } else { + charSequence250 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(250, charSequence250); + } else { + throw new RuntimeException(("Illegal union index for 'F250': "+ unionIndex250)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex251 = (decoder.readIndex()); + if (unionIndex251 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(251, null); + } else { + if (unionIndex251 == 1) { + Utf8 charSequence251; + Object oldString251 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(251); + if (oldString251 instanceof Utf8) { + charSequence251 = (decoder).readString(((Utf8) oldString251)); + } else { + charSequence251 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(251, charSequence251); + } else { + throw new RuntimeException(("Illegal union index for 'F251': "+ unionIndex251)); + } + } + int unionIndex252 = (decoder.readIndex()); + if (unionIndex252 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(252, null); + } else { + if (unionIndex252 == 1) { + Utf8 charSequence252; + Object oldString252 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(252); + if (oldString252 instanceof Utf8) { + charSequence252 = (decoder).readString(((Utf8) oldString252)); + } else { + charSequence252 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(252, charSequence252); + } else { + throw new RuntimeException(("Illegal union index for 'F252': "+ unionIndex252)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex253 = (decoder.readIndex()); + if (unionIndex253 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(253, null); + } else { + if (unionIndex253 == 1) { + Utf8 charSequence253; + Object oldString253 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(253); + if (oldString253 instanceof Utf8) { + charSequence253 = (decoder).readString(((Utf8) oldString253)); + } else { + charSequence253 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(253, charSequence253); + } else { + throw new RuntimeException(("Illegal union index for 'F253': "+ unionIndex253)); + } + } + int unionIndex254 = (decoder.readIndex()); + if (unionIndex254 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(254, null); + } else { + if (unionIndex254 == 1) { + Utf8 charSequence254; + Object oldString254 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(254); + if (oldString254 instanceof Utf8) { + charSequence254 = (decoder).readString(((Utf8) oldString254)); + } else { + charSequence254 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(254, charSequence254); + } else { + throw new RuntimeException(("Illegal union index for 'F254': "+ unionIndex254)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex255 = (decoder.readIndex()); + if (unionIndex255 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(255, null); + } else { + if (unionIndex255 == 1) { + Utf8 charSequence255; + Object oldString255 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(255); + if (oldString255 instanceof Utf8) { + charSequence255 = (decoder).readString(((Utf8) oldString255)); + } else { + charSequence255 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(255, charSequence255); + } else { + throw new RuntimeException(("Illegal union index for 'F255': "+ unionIndex255)); + } + } + int unionIndex256 = (decoder.readIndex()); + if (unionIndex256 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(256, null); + } else { + if (unionIndex256 == 1) { + Utf8 charSequence256; + Object oldString256 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(256); + if (oldString256 instanceof Utf8) { + charSequence256 = (decoder).readString(((Utf8) oldString256)); + } else { + charSequence256 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(256, charSequence256); + } else { + throw new RuntimeException(("Illegal union index for 'F256': "+ unionIndex256)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex257 = (decoder.readIndex()); + if (unionIndex257 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(257, null); + } else { + if (unionIndex257 == 1) { + Utf8 charSequence257; + Object oldString257 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(257); + if (oldString257 instanceof Utf8) { + charSequence257 = (decoder).readString(((Utf8) oldString257)); + } else { + charSequence257 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(257, charSequence257); + } else { + throw new RuntimeException(("Illegal union index for 'F257': "+ unionIndex257)); + } + } + int unionIndex258 = (decoder.readIndex()); + if (unionIndex258 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(258, null); + } else { + if (unionIndex258 == 1) { + Utf8 charSequence258; + Object oldString258 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(258); + if (oldString258 instanceof Utf8) { + charSequence258 = (decoder).readString(((Utf8) oldString258)); + } else { + charSequence258 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(258, charSequence258); + } else { + throw new RuntimeException(("Illegal union index for 'F258': "+ unionIndex258)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex259 = (decoder.readIndex()); + if (unionIndex259 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(259, null); + } else { + if (unionIndex259 == 1) { + Utf8 charSequence259; + Object oldString259 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(259); + if (oldString259 instanceof Utf8) { + charSequence259 = (decoder).readString(((Utf8) oldString259)); + } else { + charSequence259 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(259, charSequence259); + } else { + throw new RuntimeException(("Illegal union index for 'F259': "+ unionIndex259)); + } + } + int unionIndex260 = (decoder.readIndex()); + if (unionIndex260 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(260, null); + } else { + if (unionIndex260 == 1) { + Utf8 charSequence260; + Object oldString260 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(260); + if (oldString260 instanceof Utf8) { + charSequence260 = (decoder).readString(((Utf8) oldString260)); + } else { + charSequence260 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(260, charSequence260); + } else { + throw new RuntimeException(("Illegal union index for 'F260': "+ unionIndex260)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex261 = (decoder.readIndex()); + if (unionIndex261 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(261, null); + } else { + if (unionIndex261 == 1) { + Utf8 charSequence261; + Object oldString261 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(261); + if (oldString261 instanceof Utf8) { + charSequence261 = (decoder).readString(((Utf8) oldString261)); + } else { + charSequence261 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(261, charSequence261); + } else { + throw new RuntimeException(("Illegal union index for 'F261': "+ unionIndex261)); + } + } + int unionIndex262 = (decoder.readIndex()); + if (unionIndex262 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(262, null); + } else { + if (unionIndex262 == 1) { + Utf8 charSequence262; + Object oldString262 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(262); + if (oldString262 instanceof Utf8) { + charSequence262 = (decoder).readString(((Utf8) oldString262)); + } else { + charSequence262 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(262, charSequence262); + } else { + throw new RuntimeException(("Illegal union index for 'F262': "+ unionIndex262)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex263 = (decoder.readIndex()); + if (unionIndex263 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(263, null); + } else { + if (unionIndex263 == 1) { + Utf8 charSequence263; + Object oldString263 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(263); + if (oldString263 instanceof Utf8) { + charSequence263 = (decoder).readString(((Utf8) oldString263)); + } else { + charSequence263 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(263, charSequence263); + } else { + throw new RuntimeException(("Illegal union index for 'F263': "+ unionIndex263)); + } + } + int unionIndex264 = (decoder.readIndex()); + if (unionIndex264 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(264, null); + } else { + if (unionIndex264 == 1) { + Utf8 charSequence264; + Object oldString264 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(264); + if (oldString264 instanceof Utf8) { + charSequence264 = (decoder).readString(((Utf8) oldString264)); + } else { + charSequence264 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(264, charSequence264); + } else { + throw new RuntimeException(("Illegal union index for 'F264': "+ unionIndex264)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex265 = (decoder.readIndex()); + if (unionIndex265 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(265, null); + } else { + if (unionIndex265 == 1) { + Utf8 charSequence265; + Object oldString265 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(265); + if (oldString265 instanceof Utf8) { + charSequence265 = (decoder).readString(((Utf8) oldString265)); + } else { + charSequence265 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(265, charSequence265); + } else { + throw new RuntimeException(("Illegal union index for 'F265': "+ unionIndex265)); + } + } + int unionIndex266 = (decoder.readIndex()); + if (unionIndex266 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(266, null); + } else { + if (unionIndex266 == 1) { + Utf8 charSequence266; + Object oldString266 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(266); + if (oldString266 instanceof Utf8) { + charSequence266 = (decoder).readString(((Utf8) oldString266)); + } else { + charSequence266 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(266, charSequence266); + } else { + throw new RuntimeException(("Illegal union index for 'F266': "+ unionIndex266)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex267 = (decoder.readIndex()); + if (unionIndex267 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(267, null); + } else { + if (unionIndex267 == 1) { + Utf8 charSequence267; + Object oldString267 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(267); + if (oldString267 instanceof Utf8) { + charSequence267 = (decoder).readString(((Utf8) oldString267)); + } else { + charSequence267 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(267, charSequence267); + } else { + throw new RuntimeException(("Illegal union index for 'F267': "+ unionIndex267)); + } + } + int unionIndex268 = (decoder.readIndex()); + if (unionIndex268 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(268, null); + } else { + if (unionIndex268 == 1) { + Utf8 charSequence268; + Object oldString268 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(268); + if (oldString268 instanceof Utf8) { + charSequence268 = (decoder).readString(((Utf8) oldString268)); + } else { + charSequence268 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(268, charSequence268); + } else { + throw new RuntimeException(("Illegal union index for 'F268': "+ unionIndex268)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex269 = (decoder.readIndex()); + if (unionIndex269 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(269, null); + } else { + if (unionIndex269 == 1) { + Utf8 charSequence269; + Object oldString269 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(269); + if (oldString269 instanceof Utf8) { + charSequence269 = (decoder).readString(((Utf8) oldString269)); + } else { + charSequence269 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(269, charSequence269); + } else { + throw new RuntimeException(("Illegal union index for 'F269': "+ unionIndex269)); + } + } + int unionIndex270 = (decoder.readIndex()); + if (unionIndex270 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(270, null); + } else { + if (unionIndex270 == 1) { + Utf8 charSequence270; + Object oldString270 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(270); + if (oldString270 instanceof Utf8) { + charSequence270 = (decoder).readString(((Utf8) oldString270)); + } else { + charSequence270 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(270, charSequence270); + } else { + throw new RuntimeException(("Illegal union index for 'F270': "+ unionIndex270)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex271 = (decoder.readIndex()); + if (unionIndex271 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(271, null); + } else { + if (unionIndex271 == 1) { + Utf8 charSequence271; + Object oldString271 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(271); + if (oldString271 instanceof Utf8) { + charSequence271 = (decoder).readString(((Utf8) oldString271)); + } else { + charSequence271 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(271, charSequence271); + } else { + throw new RuntimeException(("Illegal union index for 'F271': "+ unionIndex271)); + } + } + int unionIndex272 = (decoder.readIndex()); + if (unionIndex272 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(272, null); + } else { + if (unionIndex272 == 1) { + Utf8 charSequence272; + Object oldString272 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(272); + if (oldString272 instanceof Utf8) { + charSequence272 = (decoder).readString(((Utf8) oldString272)); + } else { + charSequence272 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(272, charSequence272); + } else { + throw new RuntimeException(("Illegal union index for 'F272': "+ unionIndex272)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex273 = (decoder.readIndex()); + if (unionIndex273 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(273, null); + } else { + if (unionIndex273 == 1) { + Utf8 charSequence273; + Object oldString273 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(273); + if (oldString273 instanceof Utf8) { + charSequence273 = (decoder).readString(((Utf8) oldString273)); + } else { + charSequence273 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(273, charSequence273); + } else { + throw new RuntimeException(("Illegal union index for 'F273': "+ unionIndex273)); + } + } + int unionIndex274 = (decoder.readIndex()); + if (unionIndex274 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(274, null); + } else { + if (unionIndex274 == 1) { + Utf8 charSequence274; + Object oldString274 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(274); + if (oldString274 instanceof Utf8) { + charSequence274 = (decoder).readString(((Utf8) oldString274)); + } else { + charSequence274 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(274, charSequence274); + } else { + throw new RuntimeException(("Illegal union index for 'F274': "+ unionIndex274)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex275 = (decoder.readIndex()); + if (unionIndex275 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(275, null); + } else { + if (unionIndex275 == 1) { + Utf8 charSequence275; + Object oldString275 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(275); + if (oldString275 instanceof Utf8) { + charSequence275 = (decoder).readString(((Utf8) oldString275)); + } else { + charSequence275 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(275, charSequence275); + } else { + throw new RuntimeException(("Illegal union index for 'F275': "+ unionIndex275)); + } + } + int unionIndex276 = (decoder.readIndex()); + if (unionIndex276 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(276, null); + } else { + if (unionIndex276 == 1) { + Utf8 charSequence276; + Object oldString276 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(276); + if (oldString276 instanceof Utf8) { + charSequence276 = (decoder).readString(((Utf8) oldString276)); + } else { + charSequence276 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(276, charSequence276); + } else { + throw new RuntimeException(("Illegal union index for 'F276': "+ unionIndex276)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex277 = (decoder.readIndex()); + if (unionIndex277 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(277, null); + } else { + if (unionIndex277 == 1) { + Utf8 charSequence277; + Object oldString277 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(277); + if (oldString277 instanceof Utf8) { + charSequence277 = (decoder).readString(((Utf8) oldString277)); + } else { + charSequence277 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(277, charSequence277); + } else { + throw new RuntimeException(("Illegal union index for 'F277': "+ unionIndex277)); + } + } + int unionIndex278 = (decoder.readIndex()); + if (unionIndex278 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(278, null); + } else { + if (unionIndex278 == 1) { + Utf8 charSequence278; + Object oldString278 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(278); + if (oldString278 instanceof Utf8) { + charSequence278 = (decoder).readString(((Utf8) oldString278)); + } else { + charSequence278 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(278, charSequence278); + } else { + throw new RuntimeException(("Illegal union index for 'F278': "+ unionIndex278)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex279 = (decoder.readIndex()); + if (unionIndex279 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(279, null); + } else { + if (unionIndex279 == 1) { + Utf8 charSequence279; + Object oldString279 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(279); + if (oldString279 instanceof Utf8) { + charSequence279 = (decoder).readString(((Utf8) oldString279)); + } else { + charSequence279 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(279, charSequence279); + } else { + throw new RuntimeException(("Illegal union index for 'F279': "+ unionIndex279)); + } + } + int unionIndex280 = (decoder.readIndex()); + if (unionIndex280 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(280, null); + } else { + if (unionIndex280 == 1) { + Utf8 charSequence280; + Object oldString280 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(280); + if (oldString280 instanceof Utf8) { + charSequence280 = (decoder).readString(((Utf8) oldString280)); + } else { + charSequence280 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(280, charSequence280); + } else { + throw new RuntimeException(("Illegal union index for 'F280': "+ unionIndex280)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex281 = (decoder.readIndex()); + if (unionIndex281 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(281, null); + } else { + if (unionIndex281 == 1) { + Utf8 charSequence281; + Object oldString281 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(281); + if (oldString281 instanceof Utf8) { + charSequence281 = (decoder).readString(((Utf8) oldString281)); + } else { + charSequence281 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(281, charSequence281); + } else { + throw new RuntimeException(("Illegal union index for 'F281': "+ unionIndex281)); + } + } + int unionIndex282 = (decoder.readIndex()); + if (unionIndex282 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(282, null); + } else { + if (unionIndex282 == 1) { + Utf8 charSequence282; + Object oldString282 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(282); + if (oldString282 instanceof Utf8) { + charSequence282 = (decoder).readString(((Utf8) oldString282)); + } else { + charSequence282 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(282, charSequence282); + } else { + throw new RuntimeException(("Illegal union index for 'F282': "+ unionIndex282)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex283 = (decoder.readIndex()); + if (unionIndex283 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(283, null); + } else { + if (unionIndex283 == 1) { + Utf8 charSequence283; + Object oldString283 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(283); + if (oldString283 instanceof Utf8) { + charSequence283 = (decoder).readString(((Utf8) oldString283)); + } else { + charSequence283 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(283, charSequence283); + } else { + throw new RuntimeException(("Illegal union index for 'F283': "+ unionIndex283)); + } + } + int unionIndex284 = (decoder.readIndex()); + if (unionIndex284 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(284, null); + } else { + if (unionIndex284 == 1) { + Utf8 charSequence284; + Object oldString284 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(284); + if (oldString284 instanceof Utf8) { + charSequence284 = (decoder).readString(((Utf8) oldString284)); + } else { + charSequence284 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(284, charSequence284); + } else { + throw new RuntimeException(("Illegal union index for 'F284': "+ unionIndex284)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex285 = (decoder.readIndex()); + if (unionIndex285 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(285, null); + } else { + if (unionIndex285 == 1) { + Utf8 charSequence285; + Object oldString285 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(285); + if (oldString285 instanceof Utf8) { + charSequence285 = (decoder).readString(((Utf8) oldString285)); + } else { + charSequence285 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(285, charSequence285); + } else { + throw new RuntimeException(("Illegal union index for 'F285': "+ unionIndex285)); + } + } + int unionIndex286 = (decoder.readIndex()); + if (unionIndex286 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(286, null); + } else { + if (unionIndex286 == 1) { + Utf8 charSequence286; + Object oldString286 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(286); + if (oldString286 instanceof Utf8) { + charSequence286 = (decoder).readString(((Utf8) oldString286)); + } else { + charSequence286 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(286, charSequence286); + } else { + throw new RuntimeException(("Illegal union index for 'F286': "+ unionIndex286)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex287 = (decoder.readIndex()); + if (unionIndex287 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(287, null); + } else { + if (unionIndex287 == 1) { + Utf8 charSequence287; + Object oldString287 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(287); + if (oldString287 instanceof Utf8) { + charSequence287 = (decoder).readString(((Utf8) oldString287)); + } else { + charSequence287 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(287, charSequence287); + } else { + throw new RuntimeException(("Illegal union index for 'F287': "+ unionIndex287)); + } + } + int unionIndex288 = (decoder.readIndex()); + if (unionIndex288 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(288, null); + } else { + if (unionIndex288 == 1) { + Utf8 charSequence288; + Object oldString288 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(288); + if (oldString288 instanceof Utf8) { + charSequence288 = (decoder).readString(((Utf8) oldString288)); + } else { + charSequence288 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(288, charSequence288); + } else { + throw new RuntimeException(("Illegal union index for 'F288': "+ unionIndex288)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex289 = (decoder.readIndex()); + if (unionIndex289 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(289, null); + } else { + if (unionIndex289 == 1) { + Utf8 charSequence289; + Object oldString289 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(289); + if (oldString289 instanceof Utf8) { + charSequence289 = (decoder).readString(((Utf8) oldString289)); + } else { + charSequence289 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(289, charSequence289); + } else { + throw new RuntimeException(("Illegal union index for 'F289': "+ unionIndex289)); + } + } + int unionIndex290 = (decoder.readIndex()); + if (unionIndex290 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(290, null); + } else { + if (unionIndex290 == 1) { + Utf8 charSequence290; + Object oldString290 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(290); + if (oldString290 instanceof Utf8) { + charSequence290 = (decoder).readString(((Utf8) oldString290)); + } else { + charSequence290 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(290, charSequence290); + } else { + throw new RuntimeException(("Illegal union index for 'F290': "+ unionIndex290)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex291 = (decoder.readIndex()); + if (unionIndex291 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(291, null); + } else { + if (unionIndex291 == 1) { + Utf8 charSequence291; + Object oldString291 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(291); + if (oldString291 instanceof Utf8) { + charSequence291 = (decoder).readString(((Utf8) oldString291)); + } else { + charSequence291 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(291, charSequence291); + } else { + throw new RuntimeException(("Illegal union index for 'F291': "+ unionIndex291)); + } + } + int unionIndex292 = (decoder.readIndex()); + if (unionIndex292 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(292, null); + } else { + if (unionIndex292 == 1) { + Utf8 charSequence292; + Object oldString292 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(292); + if (oldString292 instanceof Utf8) { + charSequence292 = (decoder).readString(((Utf8) oldString292)); + } else { + charSequence292 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(292, charSequence292); + } else { + throw new RuntimeException(("Illegal union index for 'F292': "+ unionIndex292)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex293 = (decoder.readIndex()); + if (unionIndex293 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(293, null); + } else { + if (unionIndex293 == 1) { + Utf8 charSequence293; + Object oldString293 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(293); + if (oldString293 instanceof Utf8) { + charSequence293 = (decoder).readString(((Utf8) oldString293)); + } else { + charSequence293 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(293, charSequence293); + } else { + throw new RuntimeException(("Illegal union index for 'F293': "+ unionIndex293)); + } + } + int unionIndex294 = (decoder.readIndex()); + if (unionIndex294 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(294, null); + } else { + if (unionIndex294 == 1) { + Utf8 charSequence294; + Object oldString294 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(294); + if (oldString294 instanceof Utf8) { + charSequence294 = (decoder).readString(((Utf8) oldString294)); + } else { + charSequence294 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(294, charSequence294); + } else { + throw new RuntimeException(("Illegal union index for 'F294': "+ unionIndex294)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex295 = (decoder.readIndex()); + if (unionIndex295 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(295, null); + } else { + if (unionIndex295 == 1) { + Utf8 charSequence295; + Object oldString295 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(295); + if (oldString295 instanceof Utf8) { + charSequence295 = (decoder).readString(((Utf8) oldString295)); + } else { + charSequence295 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(295, charSequence295); + } else { + throw new RuntimeException(("Illegal union index for 'F295': "+ unionIndex295)); + } + } + int unionIndex296 = (decoder.readIndex()); + if (unionIndex296 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(296, null); + } else { + if (unionIndex296 == 1) { + Utf8 charSequence296; + Object oldString296 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(296); + if (oldString296 instanceof Utf8) { + charSequence296 = (decoder).readString(((Utf8) oldString296)); + } else { + charSequence296 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(296, charSequence296); + } else { + throw new RuntimeException(("Illegal union index for 'F296': "+ unionIndex296)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex297 = (decoder.readIndex()); + if (unionIndex297 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(297, null); + } else { + if (unionIndex297 == 1) { + Utf8 charSequence297; + Object oldString297 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(297); + if (oldString297 instanceof Utf8) { + charSequence297 = (decoder).readString(((Utf8) oldString297)); + } else { + charSequence297 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(297, charSequence297); + } else { + throw new RuntimeException(("Illegal union index for 'F297': "+ unionIndex297)); + } + } + int unionIndex298 = (decoder.readIndex()); + if (unionIndex298 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(298, null); + } else { + if (unionIndex298 == 1) { + Utf8 charSequence298; + Object oldString298 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(298); + if (oldString298 instanceof Utf8) { + charSequence298 = (decoder).readString(((Utf8) oldString298)); + } else { + charSequence298 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(298, charSequence298); + } else { + throw new RuntimeException(("Illegal union index for 'F298': "+ unionIndex298)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex299 = (decoder.readIndex()); + if (unionIndex299 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(299, null); + } else { + if (unionIndex299 == 1) { + Utf8 charSequence299; + Object oldString299 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(299); + if (oldString299 instanceof Utf8) { + charSequence299 = (decoder).readString(((Utf8) oldString299)); + } else { + charSequence299 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(299, charSequence299); + } else { + throw new RuntimeException(("Illegal union index for 'F299': "+ unionIndex299)); + } + } + int unionIndex300 = (decoder.readIndex()); + if (unionIndex300 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(300, null); + } else { + if (unionIndex300 == 1) { + Utf8 charSequence300; + Object oldString300 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(300); + if (oldString300 instanceof Utf8) { + charSequence300 = (decoder).readString(((Utf8) oldString300)); + } else { + charSequence300 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(300, charSequence300); + } else { + throw new RuntimeException(("Illegal union index for 'F300': "+ unionIndex300)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex301 = (decoder.readIndex()); + if (unionIndex301 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(301, null); + } else { + if (unionIndex301 == 1) { + Utf8 charSequence301; + Object oldString301 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(301); + if (oldString301 instanceof Utf8) { + charSequence301 = (decoder).readString(((Utf8) oldString301)); + } else { + charSequence301 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(301, charSequence301); + } else { + throw new RuntimeException(("Illegal union index for 'F301': "+ unionIndex301)); + } + } + int unionIndex302 = (decoder.readIndex()); + if (unionIndex302 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(302, null); + } else { + if (unionIndex302 == 1) { + Utf8 charSequence302; + Object oldString302 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(302); + if (oldString302 instanceof Utf8) { + charSequence302 = (decoder).readString(((Utf8) oldString302)); + } else { + charSequence302 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(302, charSequence302); + } else { + throw new RuntimeException(("Illegal union index for 'F302': "+ unionIndex302)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex303 = (decoder.readIndex()); + if (unionIndex303 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(303, null); + } else { + if (unionIndex303 == 1) { + Utf8 charSequence303; + Object oldString303 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(303); + if (oldString303 instanceof Utf8) { + charSequence303 = (decoder).readString(((Utf8) oldString303)); + } else { + charSequence303 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(303, charSequence303); + } else { + throw new RuntimeException(("Illegal union index for 'F303': "+ unionIndex303)); + } + } + int unionIndex304 = (decoder.readIndex()); + if (unionIndex304 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(304, null); + } else { + if (unionIndex304 == 1) { + Utf8 charSequence304; + Object oldString304 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(304); + if (oldString304 instanceof Utf8) { + charSequence304 = (decoder).readString(((Utf8) oldString304)); + } else { + charSequence304 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(304, charSequence304); + } else { + throw new RuntimeException(("Illegal union index for 'F304': "+ unionIndex304)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex305 = (decoder.readIndex()); + if (unionIndex305 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(305, null); + } else { + if (unionIndex305 == 1) { + Utf8 charSequence305; + Object oldString305 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(305); + if (oldString305 instanceof Utf8) { + charSequence305 = (decoder).readString(((Utf8) oldString305)); + } else { + charSequence305 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(305, charSequence305); + } else { + throw new RuntimeException(("Illegal union index for 'F305': "+ unionIndex305)); + } + } + int unionIndex306 = (decoder.readIndex()); + if (unionIndex306 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(306, null); + } else { + if (unionIndex306 == 1) { + Utf8 charSequence306; + Object oldString306 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(306); + if (oldString306 instanceof Utf8) { + charSequence306 = (decoder).readString(((Utf8) oldString306)); + } else { + charSequence306 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(306, charSequence306); + } else { + throw new RuntimeException(("Illegal union index for 'F306': "+ unionIndex306)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex307 = (decoder.readIndex()); + if (unionIndex307 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(307, null); + } else { + if (unionIndex307 == 1) { + Utf8 charSequence307; + Object oldString307 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(307); + if (oldString307 instanceof Utf8) { + charSequence307 = (decoder).readString(((Utf8) oldString307)); + } else { + charSequence307 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(307, charSequence307); + } else { + throw new RuntimeException(("Illegal union index for 'F307': "+ unionIndex307)); + } + } + int unionIndex308 = (decoder.readIndex()); + if (unionIndex308 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(308, null); + } else { + if (unionIndex308 == 1) { + Utf8 charSequence308; + Object oldString308 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(308); + if (oldString308 instanceof Utf8) { + charSequence308 = (decoder).readString(((Utf8) oldString308)); + } else { + charSequence308 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(308, charSequence308); + } else { + throw new RuntimeException(("Illegal union index for 'F308': "+ unionIndex308)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex309 = (decoder.readIndex()); + if (unionIndex309 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(309, null); + } else { + if (unionIndex309 == 1) { + Utf8 charSequence309; + Object oldString309 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(309); + if (oldString309 instanceof Utf8) { + charSequence309 = (decoder).readString(((Utf8) oldString309)); + } else { + charSequence309 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(309, charSequence309); + } else { + throw new RuntimeException(("Illegal union index for 'F309': "+ unionIndex309)); + } + } + int unionIndex310 = (decoder.readIndex()); + if (unionIndex310 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(310, null); + } else { + if (unionIndex310 == 1) { + Utf8 charSequence310; + Object oldString310 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(310); + if (oldString310 instanceof Utf8) { + charSequence310 = (decoder).readString(((Utf8) oldString310)); + } else { + charSequence310 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(310, charSequence310); + } else { + throw new RuntimeException(("Illegal union index for 'F310': "+ unionIndex310)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex311 = (decoder.readIndex()); + if (unionIndex311 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(311, null); + } else { + if (unionIndex311 == 1) { + Utf8 charSequence311; + Object oldString311 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(311); + if (oldString311 instanceof Utf8) { + charSequence311 = (decoder).readString(((Utf8) oldString311)); + } else { + charSequence311 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(311, charSequence311); + } else { + throw new RuntimeException(("Illegal union index for 'F311': "+ unionIndex311)); + } + } + int unionIndex312 = (decoder.readIndex()); + if (unionIndex312 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(312, null); + } else { + if (unionIndex312 == 1) { + Utf8 charSequence312; + Object oldString312 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(312); + if (oldString312 instanceof Utf8) { + charSequence312 = (decoder).readString(((Utf8) oldString312)); + } else { + charSequence312 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(312, charSequence312); + } else { + throw new RuntimeException(("Illegal union index for 'F312': "+ unionIndex312)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex313 = (decoder.readIndex()); + if (unionIndex313 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(313, null); + } else { + if (unionIndex313 == 1) { + Utf8 charSequence313; + Object oldString313 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(313); + if (oldString313 instanceof Utf8) { + charSequence313 = (decoder).readString(((Utf8) oldString313)); + } else { + charSequence313 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(313, charSequence313); + } else { + throw new RuntimeException(("Illegal union index for 'F313': "+ unionIndex313)); + } + } + int unionIndex314 = (decoder.readIndex()); + if (unionIndex314 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(314, null); + } else { + if (unionIndex314 == 1) { + Utf8 charSequence314; + Object oldString314 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(314); + if (oldString314 instanceof Utf8) { + charSequence314 = (decoder).readString(((Utf8) oldString314)); + } else { + charSequence314 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(314, charSequence314); + } else { + throw new RuntimeException(("Illegal union index for 'F314': "+ unionIndex314)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex315 = (decoder.readIndex()); + if (unionIndex315 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(315, null); + } else { + if (unionIndex315 == 1) { + Utf8 charSequence315; + Object oldString315 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(315); + if (oldString315 instanceof Utf8) { + charSequence315 = (decoder).readString(((Utf8) oldString315)); + } else { + charSequence315 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(315, charSequence315); + } else { + throw new RuntimeException(("Illegal union index for 'F315': "+ unionIndex315)); + } + } + int unionIndex316 = (decoder.readIndex()); + if (unionIndex316 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(316, null); + } else { + if (unionIndex316 == 1) { + Utf8 charSequence316; + Object oldString316 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(316); + if (oldString316 instanceof Utf8) { + charSequence316 = (decoder).readString(((Utf8) oldString316)); + } else { + charSequence316 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(316, charSequence316); + } else { + throw new RuntimeException(("Illegal union index for 'F316': "+ unionIndex316)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex317 = (decoder.readIndex()); + if (unionIndex317 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(317, null); + } else { + if (unionIndex317 == 1) { + Utf8 charSequence317; + Object oldString317 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(317); + if (oldString317 instanceof Utf8) { + charSequence317 = (decoder).readString(((Utf8) oldString317)); + } else { + charSequence317 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(317, charSequence317); + } else { + throw new RuntimeException(("Illegal union index for 'F317': "+ unionIndex317)); + } + } + int unionIndex318 = (decoder.readIndex()); + if (unionIndex318 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(318, null); + } else { + if (unionIndex318 == 1) { + Utf8 charSequence318; + Object oldString318 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(318); + if (oldString318 instanceof Utf8) { + charSequence318 = (decoder).readString(((Utf8) oldString318)); + } else { + charSequence318 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(318, charSequence318); + } else { + throw new RuntimeException(("Illegal union index for 'F318': "+ unionIndex318)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex319 = (decoder.readIndex()); + if (unionIndex319 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(319, null); + } else { + if (unionIndex319 == 1) { + Utf8 charSequence319; + Object oldString319 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(319); + if (oldString319 instanceof Utf8) { + charSequence319 = (decoder).readString(((Utf8) oldString319)); + } else { + charSequence319 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(319, charSequence319); + } else { + throw new RuntimeException(("Illegal union index for 'F319': "+ unionIndex319)); + } + } + int unionIndex320 = (decoder.readIndex()); + if (unionIndex320 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(320, null); + } else { + if (unionIndex320 == 1) { + Utf8 charSequence320; + Object oldString320 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(320); + if (oldString320 instanceof Utf8) { + charSequence320 = (decoder).readString(((Utf8) oldString320)); + } else { + charSequence320 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(320, charSequence320); + } else { + throw new RuntimeException(("Illegal union index for 'F320': "+ unionIndex320)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex321 = (decoder.readIndex()); + if (unionIndex321 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(321, null); + } else { + if (unionIndex321 == 1) { + Utf8 charSequence321; + Object oldString321 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(321); + if (oldString321 instanceof Utf8) { + charSequence321 = (decoder).readString(((Utf8) oldString321)); + } else { + charSequence321 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(321, charSequence321); + } else { + throw new RuntimeException(("Illegal union index for 'F321': "+ unionIndex321)); + } + } + int unionIndex322 = (decoder.readIndex()); + if (unionIndex322 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(322, null); + } else { + if (unionIndex322 == 1) { + Utf8 charSequence322; + Object oldString322 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(322); + if (oldString322 instanceof Utf8) { + charSequence322 = (decoder).readString(((Utf8) oldString322)); + } else { + charSequence322 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(322, charSequence322); + } else { + throw new RuntimeException(("Illegal union index for 'F322': "+ unionIndex322)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex323 = (decoder.readIndex()); + if (unionIndex323 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(323, null); + } else { + if (unionIndex323 == 1) { + Utf8 charSequence323; + Object oldString323 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(323); + if (oldString323 instanceof Utf8) { + charSequence323 = (decoder).readString(((Utf8) oldString323)); + } else { + charSequence323 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(323, charSequence323); + } else { + throw new RuntimeException(("Illegal union index for 'F323': "+ unionIndex323)); + } + } + int unionIndex324 = (decoder.readIndex()); + if (unionIndex324 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(324, null); + } else { + if (unionIndex324 == 1) { + Utf8 charSequence324; + Object oldString324 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(324); + if (oldString324 instanceof Utf8) { + charSequence324 = (decoder).readString(((Utf8) oldString324)); + } else { + charSequence324 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(324, charSequence324); + } else { + throw new RuntimeException(("Illegal union index for 'F324': "+ unionIndex324)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex325 = (decoder.readIndex()); + if (unionIndex325 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(325, null); + } else { + if (unionIndex325 == 1) { + Utf8 charSequence325; + Object oldString325 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(325); + if (oldString325 instanceof Utf8) { + charSequence325 = (decoder).readString(((Utf8) oldString325)); + } else { + charSequence325 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(325, charSequence325); + } else { + throw new RuntimeException(("Illegal union index for 'F325': "+ unionIndex325)); + } + } + int unionIndex326 = (decoder.readIndex()); + if (unionIndex326 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(326, null); + } else { + if (unionIndex326 == 1) { + Utf8 charSequence326; + Object oldString326 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(326); + if (oldString326 instanceof Utf8) { + charSequence326 = (decoder).readString(((Utf8) oldString326)); + } else { + charSequence326 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(326, charSequence326); + } else { + throw new RuntimeException(("Illegal union index for 'F326': "+ unionIndex326)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex327 = (decoder.readIndex()); + if (unionIndex327 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(327, null); + } else { + if (unionIndex327 == 1) { + Utf8 charSequence327; + Object oldString327 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(327); + if (oldString327 instanceof Utf8) { + charSequence327 = (decoder).readString(((Utf8) oldString327)); + } else { + charSequence327 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(327, charSequence327); + } else { + throw new RuntimeException(("Illegal union index for 'F327': "+ unionIndex327)); + } + } + int unionIndex328 = (decoder.readIndex()); + if (unionIndex328 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(328, null); + } else { + if (unionIndex328 == 1) { + Utf8 charSequence328; + Object oldString328 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(328); + if (oldString328 instanceof Utf8) { + charSequence328 = (decoder).readString(((Utf8) oldString328)); + } else { + charSequence328 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(328, charSequence328); + } else { + throw new RuntimeException(("Illegal union index for 'F328': "+ unionIndex328)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex329 = (decoder.readIndex()); + if (unionIndex329 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(329, null); + } else { + if (unionIndex329 == 1) { + Utf8 charSequence329; + Object oldString329 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(329); + if (oldString329 instanceof Utf8) { + charSequence329 = (decoder).readString(((Utf8) oldString329)); + } else { + charSequence329 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(329, charSequence329); + } else { + throw new RuntimeException(("Illegal union index for 'F329': "+ unionIndex329)); + } + } + int unionIndex330 = (decoder.readIndex()); + if (unionIndex330 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(330, null); + } else { + if (unionIndex330 == 1) { + Utf8 charSequence330; + Object oldString330 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(330); + if (oldString330 instanceof Utf8) { + charSequence330 = (decoder).readString(((Utf8) oldString330)); + } else { + charSequence330 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(330, charSequence330); + } else { + throw new RuntimeException(("Illegal union index for 'F330': "+ unionIndex330)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex331 = (decoder.readIndex()); + if (unionIndex331 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(331, null); + } else { + if (unionIndex331 == 1) { + Utf8 charSequence331; + Object oldString331 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(331); + if (oldString331 instanceof Utf8) { + charSequence331 = (decoder).readString(((Utf8) oldString331)); + } else { + charSequence331 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(331, charSequence331); + } else { + throw new RuntimeException(("Illegal union index for 'F331': "+ unionIndex331)); + } + } + int unionIndex332 = (decoder.readIndex()); + if (unionIndex332 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(332, null); + } else { + if (unionIndex332 == 1) { + Utf8 charSequence332; + Object oldString332 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(332); + if (oldString332 instanceof Utf8) { + charSequence332 = (decoder).readString(((Utf8) oldString332)); + } else { + charSequence332 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(332, charSequence332); + } else { + throw new RuntimeException(("Illegal union index for 'F332': "+ unionIndex332)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex333 = (decoder.readIndex()); + if (unionIndex333 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(333, null); + } else { + if (unionIndex333 == 1) { + Utf8 charSequence333; + Object oldString333 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(333); + if (oldString333 instanceof Utf8) { + charSequence333 = (decoder).readString(((Utf8) oldString333)); + } else { + charSequence333 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(333, charSequence333); + } else { + throw new RuntimeException(("Illegal union index for 'F333': "+ unionIndex333)); + } + } + int unionIndex334 = (decoder.readIndex()); + if (unionIndex334 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(334, null); + } else { + if (unionIndex334 == 1) { + Utf8 charSequence334; + Object oldString334 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(334); + if (oldString334 instanceof Utf8) { + charSequence334 = (decoder).readString(((Utf8) oldString334)); + } else { + charSequence334 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(334, charSequence334); + } else { + throw new RuntimeException(("Illegal union index for 'F334': "+ unionIndex334)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex335 = (decoder.readIndex()); + if (unionIndex335 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(335, null); + } else { + if (unionIndex335 == 1) { + Utf8 charSequence335; + Object oldString335 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(335); + if (oldString335 instanceof Utf8) { + charSequence335 = (decoder).readString(((Utf8) oldString335)); + } else { + charSequence335 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(335, charSequence335); + } else { + throw new RuntimeException(("Illegal union index for 'F335': "+ unionIndex335)); + } + } + int unionIndex336 = (decoder.readIndex()); + if (unionIndex336 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(336, null); + } else { + if (unionIndex336 == 1) { + Utf8 charSequence336; + Object oldString336 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(336); + if (oldString336 instanceof Utf8) { + charSequence336 = (decoder).readString(((Utf8) oldString336)); + } else { + charSequence336 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(336, charSequence336); + } else { + throw new RuntimeException(("Illegal union index for 'F336': "+ unionIndex336)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex337 = (decoder.readIndex()); + if (unionIndex337 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(337, null); + } else { + if (unionIndex337 == 1) { + Utf8 charSequence337; + Object oldString337 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(337); + if (oldString337 instanceof Utf8) { + charSequence337 = (decoder).readString(((Utf8) oldString337)); + } else { + charSequence337 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(337, charSequence337); + } else { + throw new RuntimeException(("Illegal union index for 'F337': "+ unionIndex337)); + } + } + int unionIndex338 = (decoder.readIndex()); + if (unionIndex338 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(338, null); + } else { + if (unionIndex338 == 1) { + Utf8 charSequence338; + Object oldString338 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(338); + if (oldString338 instanceof Utf8) { + charSequence338 = (decoder).readString(((Utf8) oldString338)); + } else { + charSequence338 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(338, charSequence338); + } else { + throw new RuntimeException(("Illegal union index for 'F338': "+ unionIndex338)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex339 = (decoder.readIndex()); + if (unionIndex339 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(339, null); + } else { + if (unionIndex339 == 1) { + Utf8 charSequence339; + Object oldString339 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(339); + if (oldString339 instanceof Utf8) { + charSequence339 = (decoder).readString(((Utf8) oldString339)); + } else { + charSequence339 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(339, charSequence339); + } else { + throw new RuntimeException(("Illegal union index for 'F339': "+ unionIndex339)); + } + } + int unionIndex340 = (decoder.readIndex()); + if (unionIndex340 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(340, null); + } else { + if (unionIndex340 == 1) { + Utf8 charSequence340; + Object oldString340 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(340); + if (oldString340 instanceof Utf8) { + charSequence340 = (decoder).readString(((Utf8) oldString340)); + } else { + charSequence340 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(340, charSequence340); + } else { + throw new RuntimeException(("Illegal union index for 'F340': "+ unionIndex340)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex341 = (decoder.readIndex()); + if (unionIndex341 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(341, null); + } else { + if (unionIndex341 == 1) { + Utf8 charSequence341; + Object oldString341 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(341); + if (oldString341 instanceof Utf8) { + charSequence341 = (decoder).readString(((Utf8) oldString341)); + } else { + charSequence341 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(341, charSequence341); + } else { + throw new RuntimeException(("Illegal union index for 'F341': "+ unionIndex341)); + } + } + int unionIndex342 = (decoder.readIndex()); + if (unionIndex342 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(342, null); + } else { + if (unionIndex342 == 1) { + Utf8 charSequence342; + Object oldString342 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(342); + if (oldString342 instanceof Utf8) { + charSequence342 = (decoder).readString(((Utf8) oldString342)); + } else { + charSequence342 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(342, charSequence342); + } else { + throw new RuntimeException(("Illegal union index for 'F342': "+ unionIndex342)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex343 = (decoder.readIndex()); + if (unionIndex343 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(343, null); + } else { + if (unionIndex343 == 1) { + Utf8 charSequence343; + Object oldString343 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(343); + if (oldString343 instanceof Utf8) { + charSequence343 = (decoder).readString(((Utf8) oldString343)); + } else { + charSequence343 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(343, charSequence343); + } else { + throw new RuntimeException(("Illegal union index for 'F343': "+ unionIndex343)); + } + } + int unionIndex344 = (decoder.readIndex()); + if (unionIndex344 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(344, null); + } else { + if (unionIndex344 == 1) { + Utf8 charSequence344; + Object oldString344 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(344); + if (oldString344 instanceof Utf8) { + charSequence344 = (decoder).readString(((Utf8) oldString344)); + } else { + charSequence344 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(344, charSequence344); + } else { + throw new RuntimeException(("Illegal union index for 'F344': "+ unionIndex344)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex345 = (decoder.readIndex()); + if (unionIndex345 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(345, null); + } else { + if (unionIndex345 == 1) { + Utf8 charSequence345; + Object oldString345 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(345); + if (oldString345 instanceof Utf8) { + charSequence345 = (decoder).readString(((Utf8) oldString345)); + } else { + charSequence345 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(345, charSequence345); + } else { + throw new RuntimeException(("Illegal union index for 'F345': "+ unionIndex345)); + } + } + int unionIndex346 = (decoder.readIndex()); + if (unionIndex346 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(346, null); + } else { + if (unionIndex346 == 1) { + Utf8 charSequence346; + Object oldString346 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(346); + if (oldString346 instanceof Utf8) { + charSequence346 = (decoder).readString(((Utf8) oldString346)); + } else { + charSequence346 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(346, charSequence346); + } else { + throw new RuntimeException(("Illegal union index for 'F346': "+ unionIndex346)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex347 = (decoder.readIndex()); + if (unionIndex347 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(347, null); + } else { + if (unionIndex347 == 1) { + Utf8 charSequence347; + Object oldString347 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(347); + if (oldString347 instanceof Utf8) { + charSequence347 = (decoder).readString(((Utf8) oldString347)); + } else { + charSequence347 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(347, charSequence347); + } else { + throw new RuntimeException(("Illegal union index for 'F347': "+ unionIndex347)); + } + } + int unionIndex348 = (decoder.readIndex()); + if (unionIndex348 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(348, null); + } else { + if (unionIndex348 == 1) { + Utf8 charSequence348; + Object oldString348 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(348); + if (oldString348 instanceof Utf8) { + charSequence348 = (decoder).readString(((Utf8) oldString348)); + } else { + charSequence348 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(348, charSequence348); + } else { + throw new RuntimeException(("Illegal union index for 'F348': "+ unionIndex348)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex349 = (decoder.readIndex()); + if (unionIndex349 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(349, null); + } else { + if (unionIndex349 == 1) { + Utf8 charSequence349; + Object oldString349 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(349); + if (oldString349 instanceof Utf8) { + charSequence349 = (decoder).readString(((Utf8) oldString349)); + } else { + charSequence349 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(349, charSequence349); + } else { + throw new RuntimeException(("Illegal union index for 'F349': "+ unionIndex349)); + } + } + int unionIndex350 = (decoder.readIndex()); + if (unionIndex350 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(350, null); + } else { + if (unionIndex350 == 1) { + Utf8 charSequence350; + Object oldString350 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(350); + if (oldString350 instanceof Utf8) { + charSequence350 = (decoder).readString(((Utf8) oldString350)); + } else { + charSequence350 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(350, charSequence350); + } else { + throw new RuntimeException(("Illegal union index for 'F350': "+ unionIndex350)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex351 = (decoder.readIndex()); + if (unionIndex351 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(351, null); + } else { + if (unionIndex351 == 1) { + Utf8 charSequence351; + Object oldString351 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(351); + if (oldString351 instanceof Utf8) { + charSequence351 = (decoder).readString(((Utf8) oldString351)); + } else { + charSequence351 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(351, charSequence351); + } else { + throw new RuntimeException(("Illegal union index for 'F351': "+ unionIndex351)); + } + } + int unionIndex352 = (decoder.readIndex()); + if (unionIndex352 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(352, null); + } else { + if (unionIndex352 == 1) { + Utf8 charSequence352; + Object oldString352 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(352); + if (oldString352 instanceof Utf8) { + charSequence352 = (decoder).readString(((Utf8) oldString352)); + } else { + charSequence352 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(352, charSequence352); + } else { + throw new RuntimeException(("Illegal union index for 'F352': "+ unionIndex352)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex353 = (decoder.readIndex()); + if (unionIndex353 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(353, null); + } else { + if (unionIndex353 == 1) { + Utf8 charSequence353; + Object oldString353 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(353); + if (oldString353 instanceof Utf8) { + charSequence353 = (decoder).readString(((Utf8) oldString353)); + } else { + charSequence353 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(353, charSequence353); + } else { + throw new RuntimeException(("Illegal union index for 'F353': "+ unionIndex353)); + } + } + int unionIndex354 = (decoder.readIndex()); + if (unionIndex354 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(354, null); + } else { + if (unionIndex354 == 1) { + Utf8 charSequence354; + Object oldString354 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(354); + if (oldString354 instanceof Utf8) { + charSequence354 = (decoder).readString(((Utf8) oldString354)); + } else { + charSequence354 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(354, charSequence354); + } else { + throw new RuntimeException(("Illegal union index for 'F354': "+ unionIndex354)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex355 = (decoder.readIndex()); + if (unionIndex355 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(355, null); + } else { + if (unionIndex355 == 1) { + Utf8 charSequence355; + Object oldString355 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(355); + if (oldString355 instanceof Utf8) { + charSequence355 = (decoder).readString(((Utf8) oldString355)); + } else { + charSequence355 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(355, charSequence355); + } else { + throw new RuntimeException(("Illegal union index for 'F355': "+ unionIndex355)); + } + } + int unionIndex356 = (decoder.readIndex()); + if (unionIndex356 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(356, null); + } else { + if (unionIndex356 == 1) { + Utf8 charSequence356; + Object oldString356 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(356); + if (oldString356 instanceof Utf8) { + charSequence356 = (decoder).readString(((Utf8) oldString356)); + } else { + charSequence356 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(356, charSequence356); + } else { + throw new RuntimeException(("Illegal union index for 'F356': "+ unionIndex356)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex357 = (decoder.readIndex()); + if (unionIndex357 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(357, null); + } else { + if (unionIndex357 == 1) { + Utf8 charSequence357; + Object oldString357 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(357); + if (oldString357 instanceof Utf8) { + charSequence357 = (decoder).readString(((Utf8) oldString357)); + } else { + charSequence357 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(357, charSequence357); + } else { + throw new RuntimeException(("Illegal union index for 'F357': "+ unionIndex357)); + } + } + int unionIndex358 = (decoder.readIndex()); + if (unionIndex358 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(358, null); + } else { + if (unionIndex358 == 1) { + Utf8 charSequence358; + Object oldString358 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(358); + if (oldString358 instanceof Utf8) { + charSequence358 = (decoder).readString(((Utf8) oldString358)); + } else { + charSequence358 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(358, charSequence358); + } else { + throw new RuntimeException(("Illegal union index for 'F358': "+ unionIndex358)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex359 = (decoder.readIndex()); + if (unionIndex359 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(359, null); + } else { + if (unionIndex359 == 1) { + Utf8 charSequence359; + Object oldString359 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(359); + if (oldString359 instanceof Utf8) { + charSequence359 = (decoder).readString(((Utf8) oldString359)); + } else { + charSequence359 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(359, charSequence359); + } else { + throw new RuntimeException(("Illegal union index for 'F359': "+ unionIndex359)); + } + } + int unionIndex360 = (decoder.readIndex()); + if (unionIndex360 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(360, null); + } else { + if (unionIndex360 == 1) { + Utf8 charSequence360; + Object oldString360 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(360); + if (oldString360 instanceof Utf8) { + charSequence360 = (decoder).readString(((Utf8) oldString360)); + } else { + charSequence360 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(360, charSequence360); + } else { + throw new RuntimeException(("Illegal union index for 'F360': "+ unionIndex360)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex361 = (decoder.readIndex()); + if (unionIndex361 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(361, null); + } else { + if (unionIndex361 == 1) { + Utf8 charSequence361; + Object oldString361 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(361); + if (oldString361 instanceof Utf8) { + charSequence361 = (decoder).readString(((Utf8) oldString361)); + } else { + charSequence361 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(361, charSequence361); + } else { + throw new RuntimeException(("Illegal union index for 'F361': "+ unionIndex361)); + } + } + int unionIndex362 = (decoder.readIndex()); + if (unionIndex362 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(362, null); + } else { + if (unionIndex362 == 1) { + Utf8 charSequence362; + Object oldString362 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(362); + if (oldString362 instanceof Utf8) { + charSequence362 = (decoder).readString(((Utf8) oldString362)); + } else { + charSequence362 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(362, charSequence362); + } else { + throw new RuntimeException(("Illegal union index for 'F362': "+ unionIndex362)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex363 = (decoder.readIndex()); + if (unionIndex363 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(363, null); + } else { + if (unionIndex363 == 1) { + Utf8 charSequence363; + Object oldString363 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(363); + if (oldString363 instanceof Utf8) { + charSequence363 = (decoder).readString(((Utf8) oldString363)); + } else { + charSequence363 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(363, charSequence363); + } else { + throw new RuntimeException(("Illegal union index for 'F363': "+ unionIndex363)); + } + } + int unionIndex364 = (decoder.readIndex()); + if (unionIndex364 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(364, null); + } else { + if (unionIndex364 == 1) { + Utf8 charSequence364; + Object oldString364 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(364); + if (oldString364 instanceof Utf8) { + charSequence364 = (decoder).readString(((Utf8) oldString364)); + } else { + charSequence364 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(364, charSequence364); + } else { + throw new RuntimeException(("Illegal union index for 'F364': "+ unionIndex364)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex365 = (decoder.readIndex()); + if (unionIndex365 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(365, null); + } else { + if (unionIndex365 == 1) { + Utf8 charSequence365; + Object oldString365 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(365); + if (oldString365 instanceof Utf8) { + charSequence365 = (decoder).readString(((Utf8) oldString365)); + } else { + charSequence365 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(365, charSequence365); + } else { + throw new RuntimeException(("Illegal union index for 'F365': "+ unionIndex365)); + } + } + int unionIndex366 = (decoder.readIndex()); + if (unionIndex366 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(366, null); + } else { + if (unionIndex366 == 1) { + Utf8 charSequence366; + Object oldString366 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(366); + if (oldString366 instanceof Utf8) { + charSequence366 = (decoder).readString(((Utf8) oldString366)); + } else { + charSequence366 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(366, charSequence366); + } else { + throw new RuntimeException(("Illegal union index for 'F366': "+ unionIndex366)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex367 = (decoder.readIndex()); + if (unionIndex367 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(367, null); + } else { + if (unionIndex367 == 1) { + Utf8 charSequence367; + Object oldString367 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(367); + if (oldString367 instanceof Utf8) { + charSequence367 = (decoder).readString(((Utf8) oldString367)); + } else { + charSequence367 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(367, charSequence367); + } else { + throw new RuntimeException(("Illegal union index for 'F367': "+ unionIndex367)); + } + } + int unionIndex368 = (decoder.readIndex()); + if (unionIndex368 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(368, null); + } else { + if (unionIndex368 == 1) { + Utf8 charSequence368; + Object oldString368 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(368); + if (oldString368 instanceof Utf8) { + charSequence368 = (decoder).readString(((Utf8) oldString368)); + } else { + charSequence368 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(368, charSequence368); + } else { + throw new RuntimeException(("Illegal union index for 'F368': "+ unionIndex368)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex369 = (decoder.readIndex()); + if (unionIndex369 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(369, null); + } else { + if (unionIndex369 == 1) { + Utf8 charSequence369; + Object oldString369 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(369); + if (oldString369 instanceof Utf8) { + charSequence369 = (decoder).readString(((Utf8) oldString369)); + } else { + charSequence369 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(369, charSequence369); + } else { + throw new RuntimeException(("Illegal union index for 'F369': "+ unionIndex369)); + } + } + int unionIndex370 = (decoder.readIndex()); + if (unionIndex370 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(370, null); + } else { + if (unionIndex370 == 1) { + Utf8 charSequence370; + Object oldString370 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(370); + if (oldString370 instanceof Utf8) { + charSequence370 = (decoder).readString(((Utf8) oldString370)); + } else { + charSequence370 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(370, charSequence370); + } else { + throw new RuntimeException(("Illegal union index for 'F370': "+ unionIndex370)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex371 = (decoder.readIndex()); + if (unionIndex371 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(371, null); + } else { + if (unionIndex371 == 1) { + Utf8 charSequence371; + Object oldString371 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(371); + if (oldString371 instanceof Utf8) { + charSequence371 = (decoder).readString(((Utf8) oldString371)); + } else { + charSequence371 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(371, charSequence371); + } else { + throw new RuntimeException(("Illegal union index for 'F371': "+ unionIndex371)); + } + } + int unionIndex372 = (decoder.readIndex()); + if (unionIndex372 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(372, null); + } else { + if (unionIndex372 == 1) { + Utf8 charSequence372; + Object oldString372 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(372); + if (oldString372 instanceof Utf8) { + charSequence372 = (decoder).readString(((Utf8) oldString372)); + } else { + charSequence372 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(372, charSequence372); + } else { + throw new RuntimeException(("Illegal union index for 'F372': "+ unionIndex372)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex373 = (decoder.readIndex()); + if (unionIndex373 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(373, null); + } else { + if (unionIndex373 == 1) { + Utf8 charSequence373; + Object oldString373 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(373); + if (oldString373 instanceof Utf8) { + charSequence373 = (decoder).readString(((Utf8) oldString373)); + } else { + charSequence373 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(373, charSequence373); + } else { + throw new RuntimeException(("Illegal union index for 'F373': "+ unionIndex373)); + } + } + int unionIndex374 = (decoder.readIndex()); + if (unionIndex374 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(374, null); + } else { + if (unionIndex374 == 1) { + Utf8 charSequence374; + Object oldString374 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(374); + if (oldString374 instanceof Utf8) { + charSequence374 = (decoder).readString(((Utf8) oldString374)); + } else { + charSequence374 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(374, charSequence374); + } else { + throw new RuntimeException(("Illegal union index for 'F374': "+ unionIndex374)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex375 = (decoder.readIndex()); + if (unionIndex375 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(375, null); + } else { + if (unionIndex375 == 1) { + Utf8 charSequence375; + Object oldString375 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(375); + if (oldString375 instanceof Utf8) { + charSequence375 = (decoder).readString(((Utf8) oldString375)); + } else { + charSequence375 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(375, charSequence375); + } else { + throw new RuntimeException(("Illegal union index for 'F375': "+ unionIndex375)); + } + } + int unionIndex376 = (decoder.readIndex()); + if (unionIndex376 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(376, null); + } else { + if (unionIndex376 == 1) { + Utf8 charSequence376; + Object oldString376 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(376); + if (oldString376 instanceof Utf8) { + charSequence376 = (decoder).readString(((Utf8) oldString376)); + } else { + charSequence376 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(376, charSequence376); + } else { + throw new RuntimeException(("Illegal union index for 'F376': "+ unionIndex376)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex377 = (decoder.readIndex()); + if (unionIndex377 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(377, null); + } else { + if (unionIndex377 == 1) { + Utf8 charSequence377; + Object oldString377 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(377); + if (oldString377 instanceof Utf8) { + charSequence377 = (decoder).readString(((Utf8) oldString377)); + } else { + charSequence377 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(377, charSequence377); + } else { + throw new RuntimeException(("Illegal union index for 'F377': "+ unionIndex377)); + } + } + int unionIndex378 = (decoder.readIndex()); + if (unionIndex378 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(378, null); + } else { + if (unionIndex378 == 1) { + Utf8 charSequence378; + Object oldString378 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(378); + if (oldString378 instanceof Utf8) { + charSequence378 = (decoder).readString(((Utf8) oldString378)); + } else { + charSequence378 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(378, charSequence378); + } else { + throw new RuntimeException(("Illegal union index for 'F378': "+ unionIndex378)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex379 = (decoder.readIndex()); + if (unionIndex379 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(379, null); + } else { + if (unionIndex379 == 1) { + Utf8 charSequence379; + Object oldString379 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(379); + if (oldString379 instanceof Utf8) { + charSequence379 = (decoder).readString(((Utf8) oldString379)); + } else { + charSequence379 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(379, charSequence379); + } else { + throw new RuntimeException(("Illegal union index for 'F379': "+ unionIndex379)); + } + } + int unionIndex380 = (decoder.readIndex()); + if (unionIndex380 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(380, null); + } else { + if (unionIndex380 == 1) { + Utf8 charSequence380; + Object oldString380 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(380); + if (oldString380 instanceof Utf8) { + charSequence380 = (decoder).readString(((Utf8) oldString380)); + } else { + charSequence380 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(380, charSequence380); + } else { + throw new RuntimeException(("Illegal union index for 'F380': "+ unionIndex380)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex381 = (decoder.readIndex()); + if (unionIndex381 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(381, null); + } else { + if (unionIndex381 == 1) { + Utf8 charSequence381; + Object oldString381 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(381); + if (oldString381 instanceof Utf8) { + charSequence381 = (decoder).readString(((Utf8) oldString381)); + } else { + charSequence381 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(381, charSequence381); + } else { + throw new RuntimeException(("Illegal union index for 'F381': "+ unionIndex381)); + } + } + int unionIndex382 = (decoder.readIndex()); + if (unionIndex382 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(382, null); + } else { + if (unionIndex382 == 1) { + Utf8 charSequence382; + Object oldString382 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(382); + if (oldString382 instanceof Utf8) { + charSequence382 = (decoder).readString(((Utf8) oldString382)); + } else { + charSequence382 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(382, charSequence382); + } else { + throw new RuntimeException(("Illegal union index for 'F382': "+ unionIndex382)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex383 = (decoder.readIndex()); + if (unionIndex383 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(383, null); + } else { + if (unionIndex383 == 1) { + Utf8 charSequence383; + Object oldString383 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(383); + if (oldString383 instanceof Utf8) { + charSequence383 = (decoder).readString(((Utf8) oldString383)); + } else { + charSequence383 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(383, charSequence383); + } else { + throw new RuntimeException(("Illegal union index for 'F383': "+ unionIndex383)); + } + } + int unionIndex384 = (decoder.readIndex()); + if (unionIndex384 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(384, null); + } else { + if (unionIndex384 == 1) { + Utf8 charSequence384; + Object oldString384 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(384); + if (oldString384 instanceof Utf8) { + charSequence384 = (decoder).readString(((Utf8) oldString384)); + } else { + charSequence384 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(384, charSequence384); + } else { + throw new RuntimeException(("Illegal union index for 'F384': "+ unionIndex384)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex385 = (decoder.readIndex()); + if (unionIndex385 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(385, null); + } else { + if (unionIndex385 == 1) { + Utf8 charSequence385; + Object oldString385 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(385); + if (oldString385 instanceof Utf8) { + charSequence385 = (decoder).readString(((Utf8) oldString385)); + } else { + charSequence385 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(385, charSequence385); + } else { + throw new RuntimeException(("Illegal union index for 'F385': "+ unionIndex385)); + } + } + int unionIndex386 = (decoder.readIndex()); + if (unionIndex386 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(386, null); + } else { + if (unionIndex386 == 1) { + Utf8 charSequence386; + Object oldString386 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(386); + if (oldString386 instanceof Utf8) { + charSequence386 = (decoder).readString(((Utf8) oldString386)); + } else { + charSequence386 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(386, charSequence386); + } else { + throw new RuntimeException(("Illegal union index for 'F386': "+ unionIndex386)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex387 = (decoder.readIndex()); + if (unionIndex387 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(387, null); + } else { + if (unionIndex387 == 1) { + Utf8 charSequence387; + Object oldString387 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(387); + if (oldString387 instanceof Utf8) { + charSequence387 = (decoder).readString(((Utf8) oldString387)); + } else { + charSequence387 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(387, charSequence387); + } else { + throw new RuntimeException(("Illegal union index for 'F387': "+ unionIndex387)); + } + } + int unionIndex388 = (decoder.readIndex()); + if (unionIndex388 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(388, null); + } else { + if (unionIndex388 == 1) { + Utf8 charSequence388; + Object oldString388 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(388); + if (oldString388 instanceof Utf8) { + charSequence388 = (decoder).readString(((Utf8) oldString388)); + } else { + charSequence388 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(388, charSequence388); + } else { + throw new RuntimeException(("Illegal union index for 'F388': "+ unionIndex388)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex389 = (decoder.readIndex()); + if (unionIndex389 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(389, null); + } else { + if (unionIndex389 == 1) { + Utf8 charSequence389; + Object oldString389 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(389); + if (oldString389 instanceof Utf8) { + charSequence389 = (decoder).readString(((Utf8) oldString389)); + } else { + charSequence389 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(389, charSequence389); + } else { + throw new RuntimeException(("Illegal union index for 'F389': "+ unionIndex389)); + } + } + int unionIndex390 = (decoder.readIndex()); + if (unionIndex390 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(390, null); + } else { + if (unionIndex390 == 1) { + Utf8 charSequence390; + Object oldString390 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(390); + if (oldString390 instanceof Utf8) { + charSequence390 = (decoder).readString(((Utf8) oldString390)); + } else { + charSequence390 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(390, charSequence390); + } else { + throw new RuntimeException(("Illegal union index for 'F390': "+ unionIndex390)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex391 = (decoder.readIndex()); + if (unionIndex391 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(391, null); + } else { + if (unionIndex391 == 1) { + Utf8 charSequence391; + Object oldString391 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(391); + if (oldString391 instanceof Utf8) { + charSequence391 = (decoder).readString(((Utf8) oldString391)); + } else { + charSequence391 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(391, charSequence391); + } else { + throw new RuntimeException(("Illegal union index for 'F391': "+ unionIndex391)); + } + } + int unionIndex392 = (decoder.readIndex()); + if (unionIndex392 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(392, null); + } else { + if (unionIndex392 == 1) { + Utf8 charSequence392; + Object oldString392 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(392); + if (oldString392 instanceof Utf8) { + charSequence392 = (decoder).readString(((Utf8) oldString392)); + } else { + charSequence392 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(392, charSequence392); + } else { + throw new RuntimeException(("Illegal union index for 'F392': "+ unionIndex392)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex393 = (decoder.readIndex()); + if (unionIndex393 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(393, null); + } else { + if (unionIndex393 == 1) { + Utf8 charSequence393; + Object oldString393 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(393); + if (oldString393 instanceof Utf8) { + charSequence393 = (decoder).readString(((Utf8) oldString393)); + } else { + charSequence393 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(393, charSequence393); + } else { + throw new RuntimeException(("Illegal union index for 'F393': "+ unionIndex393)); + } + } + int unionIndex394 = (decoder.readIndex()); + if (unionIndex394 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(394, null); + } else { + if (unionIndex394 == 1) { + Utf8 charSequence394; + Object oldString394 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(394); + if (oldString394 instanceof Utf8) { + charSequence394 = (decoder).readString(((Utf8) oldString394)); + } else { + charSequence394 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(394, charSequence394); + } else { + throw new RuntimeException(("Illegal union index for 'F394': "+ unionIndex394)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex395 = (decoder.readIndex()); + if (unionIndex395 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(395, null); + } else { + if (unionIndex395 == 1) { + Utf8 charSequence395; + Object oldString395 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(395); + if (oldString395 instanceof Utf8) { + charSequence395 = (decoder).readString(((Utf8) oldString395)); + } else { + charSequence395 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(395, charSequence395); + } else { + throw new RuntimeException(("Illegal union index for 'F395': "+ unionIndex395)); + } + } + int unionIndex396 = (decoder.readIndex()); + if (unionIndex396 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(396, null); + } else { + if (unionIndex396 == 1) { + Utf8 charSequence396; + Object oldString396 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(396); + if (oldString396 instanceof Utf8) { + charSequence396 = (decoder).readString(((Utf8) oldString396)); + } else { + charSequence396 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(396, charSequence396); + } else { + throw new RuntimeException(("Illegal union index for 'F396': "+ unionIndex396)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex397 = (decoder.readIndex()); + if (unionIndex397 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(397, null); + } else { + if (unionIndex397 == 1) { + Utf8 charSequence397; + Object oldString397 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(397); + if (oldString397 instanceof Utf8) { + charSequence397 = (decoder).readString(((Utf8) oldString397)); + } else { + charSequence397 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(397, charSequence397); + } else { + throw new RuntimeException(("Illegal union index for 'F397': "+ unionIndex397)); + } + } + int unionIndex398 = (decoder.readIndex()); + if (unionIndex398 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(398, null); + } else { + if (unionIndex398 == 1) { + Utf8 charSequence398; + Object oldString398 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(398); + if (oldString398 instanceof Utf8) { + charSequence398 = (decoder).readString(((Utf8) oldString398)); + } else { + charSequence398 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(398, charSequence398); + } else { + throw new RuntimeException(("Illegal union index for 'F398': "+ unionIndex398)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex399 = (decoder.readIndex()); + if (unionIndex399 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(399, null); + } else { + if (unionIndex399 == 1) { + Utf8 charSequence399; + Object oldString399 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(399); + if (oldString399 instanceof Utf8) { + charSequence399 = (decoder).readString(((Utf8) oldString399)); + } else { + charSequence399 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(399, charSequence399); + } else { + throw new RuntimeException(("Illegal union index for 'F399': "+ unionIndex399)); + } + } + int unionIndex400 = (decoder.readIndex()); + if (unionIndex400 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(400, null); + } else { + if (unionIndex400 == 1) { + Utf8 charSequence400; + Object oldString400 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(400); + if (oldString400 instanceof Utf8) { + charSequence400 = (decoder).readString(((Utf8) oldString400)); + } else { + charSequence400 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(400, charSequence400); + } else { + throw new RuntimeException(("Illegal union index for 'F400': "+ unionIndex400)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex401 = (decoder.readIndex()); + if (unionIndex401 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(401, null); + } else { + if (unionIndex401 == 1) { + Utf8 charSequence401; + Object oldString401 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(401); + if (oldString401 instanceof Utf8) { + charSequence401 = (decoder).readString(((Utf8) oldString401)); + } else { + charSequence401 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(401, charSequence401); + } else { + throw new RuntimeException(("Illegal union index for 'F401': "+ unionIndex401)); + } + } + int unionIndex402 = (decoder.readIndex()); + if (unionIndex402 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(402, null); + } else { + if (unionIndex402 == 1) { + Utf8 charSequence402; + Object oldString402 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(402); + if (oldString402 instanceof Utf8) { + charSequence402 = (decoder).readString(((Utf8) oldString402)); + } else { + charSequence402 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(402, charSequence402); + } else { + throw new RuntimeException(("Illegal union index for 'F402': "+ unionIndex402)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex403 = (decoder.readIndex()); + if (unionIndex403 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(403, null); + } else { + if (unionIndex403 == 1) { + Utf8 charSequence403; + Object oldString403 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(403); + if (oldString403 instanceof Utf8) { + charSequence403 = (decoder).readString(((Utf8) oldString403)); + } else { + charSequence403 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(403, charSequence403); + } else { + throw new RuntimeException(("Illegal union index for 'F403': "+ unionIndex403)); + } + } + int unionIndex404 = (decoder.readIndex()); + if (unionIndex404 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(404, null); + } else { + if (unionIndex404 == 1) { + Utf8 charSequence404; + Object oldString404 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(404); + if (oldString404 instanceof Utf8) { + charSequence404 = (decoder).readString(((Utf8) oldString404)); + } else { + charSequence404 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(404, charSequence404); + } else { + throw new RuntimeException(("Illegal union index for 'F404': "+ unionIndex404)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex405 = (decoder.readIndex()); + if (unionIndex405 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(405, null); + } else { + if (unionIndex405 == 1) { + Utf8 charSequence405; + Object oldString405 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(405); + if (oldString405 instanceof Utf8) { + charSequence405 = (decoder).readString(((Utf8) oldString405)); + } else { + charSequence405 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(405, charSequence405); + } else { + throw new RuntimeException(("Illegal union index for 'F405': "+ unionIndex405)); + } + } + int unionIndex406 = (decoder.readIndex()); + if (unionIndex406 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(406, null); + } else { + if (unionIndex406 == 1) { + Utf8 charSequence406; + Object oldString406 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(406); + if (oldString406 instanceof Utf8) { + charSequence406 = (decoder).readString(((Utf8) oldString406)); + } else { + charSequence406 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(406, charSequence406); + } else { + throw new RuntimeException(("Illegal union index for 'F406': "+ unionIndex406)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex407 = (decoder.readIndex()); + if (unionIndex407 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(407, null); + } else { + if (unionIndex407 == 1) { + Utf8 charSequence407; + Object oldString407 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(407); + if (oldString407 instanceof Utf8) { + charSequence407 = (decoder).readString(((Utf8) oldString407)); + } else { + charSequence407 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(407, charSequence407); + } else { + throw new RuntimeException(("Illegal union index for 'F407': "+ unionIndex407)); + } + } + int unionIndex408 = (decoder.readIndex()); + if (unionIndex408 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(408, null); + } else { + if (unionIndex408 == 1) { + Utf8 charSequence408; + Object oldString408 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(408); + if (oldString408 instanceof Utf8) { + charSequence408 = (decoder).readString(((Utf8) oldString408)); + } else { + charSequence408 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(408, charSequence408); + } else { + throw new RuntimeException(("Illegal union index for 'F408': "+ unionIndex408)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex409 = (decoder.readIndex()); + if (unionIndex409 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(409, null); + } else { + if (unionIndex409 == 1) { + Utf8 charSequence409; + Object oldString409 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(409); + if (oldString409 instanceof Utf8) { + charSequence409 = (decoder).readString(((Utf8) oldString409)); + } else { + charSequence409 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(409, charSequence409); + } else { + throw new RuntimeException(("Illegal union index for 'F409': "+ unionIndex409)); + } + } + int unionIndex410 = (decoder.readIndex()); + if (unionIndex410 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(410, null); + } else { + if (unionIndex410 == 1) { + Utf8 charSequence410; + Object oldString410 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(410); + if (oldString410 instanceof Utf8) { + charSequence410 = (decoder).readString(((Utf8) oldString410)); + } else { + charSequence410 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(410, charSequence410); + } else { + throw new RuntimeException(("Illegal union index for 'F410': "+ unionIndex410)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex411 = (decoder.readIndex()); + if (unionIndex411 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(411, null); + } else { + if (unionIndex411 == 1) { + Utf8 charSequence411; + Object oldString411 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(411); + if (oldString411 instanceof Utf8) { + charSequence411 = (decoder).readString(((Utf8) oldString411)); + } else { + charSequence411 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(411, charSequence411); + } else { + throw new RuntimeException(("Illegal union index for 'F411': "+ unionIndex411)); + } + } + int unionIndex412 = (decoder.readIndex()); + if (unionIndex412 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(412, null); + } else { + if (unionIndex412 == 1) { + Utf8 charSequence412; + Object oldString412 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(412); + if (oldString412 instanceof Utf8) { + charSequence412 = (decoder).readString(((Utf8) oldString412)); + } else { + charSequence412 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(412, charSequence412); + } else { + throw new RuntimeException(("Illegal union index for 'F412': "+ unionIndex412)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex413 = (decoder.readIndex()); + if (unionIndex413 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(413, null); + } else { + if (unionIndex413 == 1) { + Utf8 charSequence413; + Object oldString413 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(413); + if (oldString413 instanceof Utf8) { + charSequence413 = (decoder).readString(((Utf8) oldString413)); + } else { + charSequence413 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(413, charSequence413); + } else { + throw new RuntimeException(("Illegal union index for 'F413': "+ unionIndex413)); + } + } + int unionIndex414 = (decoder.readIndex()); + if (unionIndex414 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(414, null); + } else { + if (unionIndex414 == 1) { + Utf8 charSequence414; + Object oldString414 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(414); + if (oldString414 instanceof Utf8) { + charSequence414 = (decoder).readString(((Utf8) oldString414)); + } else { + charSequence414 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(414, charSequence414); + } else { + throw new RuntimeException(("Illegal union index for 'F414': "+ unionIndex414)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex415 = (decoder.readIndex()); + if (unionIndex415 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(415, null); + } else { + if (unionIndex415 == 1) { + Utf8 charSequence415; + Object oldString415 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(415); + if (oldString415 instanceof Utf8) { + charSequence415 = (decoder).readString(((Utf8) oldString415)); + } else { + charSequence415 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(415, charSequence415); + } else { + throw new RuntimeException(("Illegal union index for 'F415': "+ unionIndex415)); + } + } + int unionIndex416 = (decoder.readIndex()); + if (unionIndex416 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(416, null); + } else { + if (unionIndex416 == 1) { + Utf8 charSequence416; + Object oldString416 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(416); + if (oldString416 instanceof Utf8) { + charSequence416 = (decoder).readString(((Utf8) oldString416)); + } else { + charSequence416 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(416, charSequence416); + } else { + throw new RuntimeException(("Illegal union index for 'F416': "+ unionIndex416)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex417 = (decoder.readIndex()); + if (unionIndex417 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(417, null); + } else { + if (unionIndex417 == 1) { + Utf8 charSequence417; + Object oldString417 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(417); + if (oldString417 instanceof Utf8) { + charSequence417 = (decoder).readString(((Utf8) oldString417)); + } else { + charSequence417 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(417, charSequence417); + } else { + throw new RuntimeException(("Illegal union index for 'F417': "+ unionIndex417)); + } + } + int unionIndex418 = (decoder.readIndex()); + if (unionIndex418 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(418, null); + } else { + if (unionIndex418 == 1) { + Utf8 charSequence418; + Object oldString418 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(418); + if (oldString418 instanceof Utf8) { + charSequence418 = (decoder).readString(((Utf8) oldString418)); + } else { + charSequence418 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(418, charSequence418); + } else { + throw new RuntimeException(("Illegal union index for 'F418': "+ unionIndex418)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex419 = (decoder.readIndex()); + if (unionIndex419 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(419, null); + } else { + if (unionIndex419 == 1) { + Utf8 charSequence419; + Object oldString419 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(419); + if (oldString419 instanceof Utf8) { + charSequence419 = (decoder).readString(((Utf8) oldString419)); + } else { + charSequence419 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(419, charSequence419); + } else { + throw new RuntimeException(("Illegal union index for 'F419': "+ unionIndex419)); + } + } + int unionIndex420 = (decoder.readIndex()); + if (unionIndex420 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(420, null); + } else { + if (unionIndex420 == 1) { + Utf8 charSequence420; + Object oldString420 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(420); + if (oldString420 instanceof Utf8) { + charSequence420 = (decoder).readString(((Utf8) oldString420)); + } else { + charSequence420 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(420, charSequence420); + } else { + throw new RuntimeException(("Illegal union index for 'F420': "+ unionIndex420)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex421 = (decoder.readIndex()); + if (unionIndex421 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(421, null); + } else { + if (unionIndex421 == 1) { + Utf8 charSequence421; + Object oldString421 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(421); + if (oldString421 instanceof Utf8) { + charSequence421 = (decoder).readString(((Utf8) oldString421)); + } else { + charSequence421 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(421, charSequence421); + } else { + throw new RuntimeException(("Illegal union index for 'F421': "+ unionIndex421)); + } + } + int unionIndex422 = (decoder.readIndex()); + if (unionIndex422 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(422, null); + } else { + if (unionIndex422 == 1) { + Utf8 charSequence422; + Object oldString422 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(422); + if (oldString422 instanceof Utf8) { + charSequence422 = (decoder).readString(((Utf8) oldString422)); + } else { + charSequence422 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(422, charSequence422); + } else { + throw new RuntimeException(("Illegal union index for 'F422': "+ unionIndex422)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex423 = (decoder.readIndex()); + if (unionIndex423 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(423, null); + } else { + if (unionIndex423 == 1) { + Utf8 charSequence423; + Object oldString423 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(423); + if (oldString423 instanceof Utf8) { + charSequence423 = (decoder).readString(((Utf8) oldString423)); + } else { + charSequence423 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(423, charSequence423); + } else { + throw new RuntimeException(("Illegal union index for 'F423': "+ unionIndex423)); + } + } + int unionIndex424 = (decoder.readIndex()); + if (unionIndex424 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(424, null); + } else { + if (unionIndex424 == 1) { + Utf8 charSequence424; + Object oldString424 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(424); + if (oldString424 instanceof Utf8) { + charSequence424 = (decoder).readString(((Utf8) oldString424)); + } else { + charSequence424 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(424, charSequence424); + } else { + throw new RuntimeException(("Illegal union index for 'F424': "+ unionIndex424)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex425 = (decoder.readIndex()); + if (unionIndex425 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(425, null); + } else { + if (unionIndex425 == 1) { + Utf8 charSequence425; + Object oldString425 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(425); + if (oldString425 instanceof Utf8) { + charSequence425 = (decoder).readString(((Utf8) oldString425)); + } else { + charSequence425 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(425, charSequence425); + } else { + throw new RuntimeException(("Illegal union index for 'F425': "+ unionIndex425)); + } + } + int unionIndex426 = (decoder.readIndex()); + if (unionIndex426 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(426, null); + } else { + if (unionIndex426 == 1) { + Utf8 charSequence426; + Object oldString426 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(426); + if (oldString426 instanceof Utf8) { + charSequence426 = (decoder).readString(((Utf8) oldString426)); + } else { + charSequence426 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(426, charSequence426); + } else { + throw new RuntimeException(("Illegal union index for 'F426': "+ unionIndex426)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex427 = (decoder.readIndex()); + if (unionIndex427 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(427, null); + } else { + if (unionIndex427 == 1) { + Utf8 charSequence427; + Object oldString427 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(427); + if (oldString427 instanceof Utf8) { + charSequence427 = (decoder).readString(((Utf8) oldString427)); + } else { + charSequence427 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(427, charSequence427); + } else { + throw new RuntimeException(("Illegal union index for 'F427': "+ unionIndex427)); + } + } + int unionIndex428 = (decoder.readIndex()); + if (unionIndex428 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(428, null); + } else { + if (unionIndex428 == 1) { + Utf8 charSequence428; + Object oldString428 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(428); + if (oldString428 instanceof Utf8) { + charSequence428 = (decoder).readString(((Utf8) oldString428)); + } else { + charSequence428 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(428, charSequence428); + } else { + throw new RuntimeException(("Illegal union index for 'F428': "+ unionIndex428)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex429 = (decoder.readIndex()); + if (unionIndex429 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(429, null); + } else { + if (unionIndex429 == 1) { + Utf8 charSequence429; + Object oldString429 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(429); + if (oldString429 instanceof Utf8) { + charSequence429 = (decoder).readString(((Utf8) oldString429)); + } else { + charSequence429 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(429, charSequence429); + } else { + throw new RuntimeException(("Illegal union index for 'F429': "+ unionIndex429)); + } + } + int unionIndex430 = (decoder.readIndex()); + if (unionIndex430 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(430, null); + } else { + if (unionIndex430 == 1) { + Utf8 charSequence430; + Object oldString430 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(430); + if (oldString430 instanceof Utf8) { + charSequence430 = (decoder).readString(((Utf8) oldString430)); + } else { + charSequence430 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(430, charSequence430); + } else { + throw new RuntimeException(("Illegal union index for 'F430': "+ unionIndex430)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex431 = (decoder.readIndex()); + if (unionIndex431 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(431, null); + } else { + if (unionIndex431 == 1) { + Utf8 charSequence431; + Object oldString431 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(431); + if (oldString431 instanceof Utf8) { + charSequence431 = (decoder).readString(((Utf8) oldString431)); + } else { + charSequence431 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(431, charSequence431); + } else { + throw new RuntimeException(("Illegal union index for 'F431': "+ unionIndex431)); + } + } + int unionIndex432 = (decoder.readIndex()); + if (unionIndex432 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(432, null); + } else { + if (unionIndex432 == 1) { + Utf8 charSequence432; + Object oldString432 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(432); + if (oldString432 instanceof Utf8) { + charSequence432 = (decoder).readString(((Utf8) oldString432)); + } else { + charSequence432 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(432, charSequence432); + } else { + throw new RuntimeException(("Illegal union index for 'F432': "+ unionIndex432)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex433 = (decoder.readIndex()); + if (unionIndex433 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(433, null); + } else { + if (unionIndex433 == 1) { + Utf8 charSequence433; + Object oldString433 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(433); + if (oldString433 instanceof Utf8) { + charSequence433 = (decoder).readString(((Utf8) oldString433)); + } else { + charSequence433 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(433, charSequence433); + } else { + throw new RuntimeException(("Illegal union index for 'F433': "+ unionIndex433)); + } + } + int unionIndex434 = (decoder.readIndex()); + if (unionIndex434 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(434, null); + } else { + if (unionIndex434 == 1) { + Utf8 charSequence434; + Object oldString434 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(434); + if (oldString434 instanceof Utf8) { + charSequence434 = (decoder).readString(((Utf8) oldString434)); + } else { + charSequence434 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(434, charSequence434); + } else { + throw new RuntimeException(("Illegal union index for 'F434': "+ unionIndex434)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex435 = (decoder.readIndex()); + if (unionIndex435 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(435, null); + } else { + if (unionIndex435 == 1) { + Utf8 charSequence435; + Object oldString435 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(435); + if (oldString435 instanceof Utf8) { + charSequence435 = (decoder).readString(((Utf8) oldString435)); + } else { + charSequence435 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(435, charSequence435); + } else { + throw new RuntimeException(("Illegal union index for 'F435': "+ unionIndex435)); + } + } + int unionIndex436 = (decoder.readIndex()); + if (unionIndex436 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(436, null); + } else { + if (unionIndex436 == 1) { + Utf8 charSequence436; + Object oldString436 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(436); + if (oldString436 instanceof Utf8) { + charSequence436 = (decoder).readString(((Utf8) oldString436)); + } else { + charSequence436 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(436, charSequence436); + } else { + throw new RuntimeException(("Illegal union index for 'F436': "+ unionIndex436)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex437 = (decoder.readIndex()); + if (unionIndex437 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(437, null); + } else { + if (unionIndex437 == 1) { + Utf8 charSequence437; + Object oldString437 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(437); + if (oldString437 instanceof Utf8) { + charSequence437 = (decoder).readString(((Utf8) oldString437)); + } else { + charSequence437 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(437, charSequence437); + } else { + throw new RuntimeException(("Illegal union index for 'F437': "+ unionIndex437)); + } + } + int unionIndex438 = (decoder.readIndex()); + if (unionIndex438 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(438, null); + } else { + if (unionIndex438 == 1) { + Utf8 charSequence438; + Object oldString438 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(438); + if (oldString438 instanceof Utf8) { + charSequence438 = (decoder).readString(((Utf8) oldString438)); + } else { + charSequence438 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(438, charSequence438); + } else { + throw new RuntimeException(("Illegal union index for 'F438': "+ unionIndex438)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex439 = (decoder.readIndex()); + if (unionIndex439 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(439, null); + } else { + if (unionIndex439 == 1) { + Utf8 charSequence439; + Object oldString439 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(439); + if (oldString439 instanceof Utf8) { + charSequence439 = (decoder).readString(((Utf8) oldString439)); + } else { + charSequence439 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(439, charSequence439); + } else { + throw new RuntimeException(("Illegal union index for 'F439': "+ unionIndex439)); + } + } + int unionIndex440 = (decoder.readIndex()); + if (unionIndex440 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(440, null); + } else { + if (unionIndex440 == 1) { + Utf8 charSequence440; + Object oldString440 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(440); + if (oldString440 instanceof Utf8) { + charSequence440 = (decoder).readString(((Utf8) oldString440)); + } else { + charSequence440 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(440, charSequence440); + } else { + throw new RuntimeException(("Illegal union index for 'F440': "+ unionIndex440)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex441 = (decoder.readIndex()); + if (unionIndex441 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(441, null); + } else { + if (unionIndex441 == 1) { + Utf8 charSequence441; + Object oldString441 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(441); + if (oldString441 instanceof Utf8) { + charSequence441 = (decoder).readString(((Utf8) oldString441)); + } else { + charSequence441 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(441, charSequence441); + } else { + throw new RuntimeException(("Illegal union index for 'F441': "+ unionIndex441)); + } + } + int unionIndex442 = (decoder.readIndex()); + if (unionIndex442 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(442, null); + } else { + if (unionIndex442 == 1) { + Utf8 charSequence442; + Object oldString442 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(442); + if (oldString442 instanceof Utf8) { + charSequence442 = (decoder).readString(((Utf8) oldString442)); + } else { + charSequence442 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(442, charSequence442); + } else { + throw new RuntimeException(("Illegal union index for 'F442': "+ unionIndex442)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex443 = (decoder.readIndex()); + if (unionIndex443 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(443, null); + } else { + if (unionIndex443 == 1) { + Utf8 charSequence443; + Object oldString443 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(443); + if (oldString443 instanceof Utf8) { + charSequence443 = (decoder).readString(((Utf8) oldString443)); + } else { + charSequence443 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(443, charSequence443); + } else { + throw new RuntimeException(("Illegal union index for 'F443': "+ unionIndex443)); + } + } + int unionIndex444 = (decoder.readIndex()); + if (unionIndex444 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(444, null); + } else { + if (unionIndex444 == 1) { + Utf8 charSequence444; + Object oldString444 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(444); + if (oldString444 instanceof Utf8) { + charSequence444 = (decoder).readString(((Utf8) oldString444)); + } else { + charSequence444 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(444, charSequence444); + } else { + throw new RuntimeException(("Illegal union index for 'F444': "+ unionIndex444)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex445 = (decoder.readIndex()); + if (unionIndex445 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(445, null); + } else { + if (unionIndex445 == 1) { + Utf8 charSequence445; + Object oldString445 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(445); + if (oldString445 instanceof Utf8) { + charSequence445 = (decoder).readString(((Utf8) oldString445)); + } else { + charSequence445 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(445, charSequence445); + } else { + throw new RuntimeException(("Illegal union index for 'F445': "+ unionIndex445)); + } + } + int unionIndex446 = (decoder.readIndex()); + if (unionIndex446 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(446, null); + } else { + if (unionIndex446 == 1) { + Utf8 charSequence446; + Object oldString446 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(446); + if (oldString446 instanceof Utf8) { + charSequence446 = (decoder).readString(((Utf8) oldString446)); + } else { + charSequence446 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(446, charSequence446); + } else { + throw new RuntimeException(("Illegal union index for 'F446': "+ unionIndex446)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex447 = (decoder.readIndex()); + if (unionIndex447 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(447, null); + } else { + if (unionIndex447 == 1) { + Utf8 charSequence447; + Object oldString447 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(447); + if (oldString447 instanceof Utf8) { + charSequence447 = (decoder).readString(((Utf8) oldString447)); + } else { + charSequence447 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(447, charSequence447); + } else { + throw new RuntimeException(("Illegal union index for 'F447': "+ unionIndex447)); + } + } + int unionIndex448 = (decoder.readIndex()); + if (unionIndex448 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(448, null); + } else { + if (unionIndex448 == 1) { + Utf8 charSequence448; + Object oldString448 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(448); + if (oldString448 instanceof Utf8) { + charSequence448 = (decoder).readString(((Utf8) oldString448)); + } else { + charSequence448 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(448, charSequence448); + } else { + throw new RuntimeException(("Illegal union index for 'F448': "+ unionIndex448)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex449 = (decoder.readIndex()); + if (unionIndex449 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(449, null); + } else { + if (unionIndex449 == 1) { + Utf8 charSequence449; + Object oldString449 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(449); + if (oldString449 instanceof Utf8) { + charSequence449 = (decoder).readString(((Utf8) oldString449)); + } else { + charSequence449 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(449, charSequence449); + } else { + throw new RuntimeException(("Illegal union index for 'F449': "+ unionIndex449)); + } + } + int unionIndex450 = (decoder.readIndex()); + if (unionIndex450 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(450, null); + } else { + if (unionIndex450 == 1) { + Utf8 charSequence450; + Object oldString450 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(450); + if (oldString450 instanceof Utf8) { + charSequence450 = (decoder).readString(((Utf8) oldString450)); + } else { + charSequence450 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(450, charSequence450); + } else { + throw new RuntimeException(("Illegal union index for 'F450': "+ unionIndex450)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex451 = (decoder.readIndex()); + if (unionIndex451 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(451, null); + } else { + if (unionIndex451 == 1) { + Utf8 charSequence451; + Object oldString451 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(451); + if (oldString451 instanceof Utf8) { + charSequence451 = (decoder).readString(((Utf8) oldString451)); + } else { + charSequence451 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(451, charSequence451); + } else { + throw new RuntimeException(("Illegal union index for 'F451': "+ unionIndex451)); + } + } + int unionIndex452 = (decoder.readIndex()); + if (unionIndex452 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(452, null); + } else { + if (unionIndex452 == 1) { + Utf8 charSequence452; + Object oldString452 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(452); + if (oldString452 instanceof Utf8) { + charSequence452 = (decoder).readString(((Utf8) oldString452)); + } else { + charSequence452 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(452, charSequence452); + } else { + throw new RuntimeException(("Illegal union index for 'F452': "+ unionIndex452)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex453 = (decoder.readIndex()); + if (unionIndex453 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(453, null); + } else { + if (unionIndex453 == 1) { + Utf8 charSequence453; + Object oldString453 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(453); + if (oldString453 instanceof Utf8) { + charSequence453 = (decoder).readString(((Utf8) oldString453)); + } else { + charSequence453 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(453, charSequence453); + } else { + throw new RuntimeException(("Illegal union index for 'F453': "+ unionIndex453)); + } + } + int unionIndex454 = (decoder.readIndex()); + if (unionIndex454 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(454, null); + } else { + if (unionIndex454 == 1) { + Utf8 charSequence454; + Object oldString454 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(454); + if (oldString454 instanceof Utf8) { + charSequence454 = (decoder).readString(((Utf8) oldString454)); + } else { + charSequence454 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(454, charSequence454); + } else { + throw new RuntimeException(("Illegal union index for 'F454': "+ unionIndex454)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex455 = (decoder.readIndex()); + if (unionIndex455 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(455, null); + } else { + if (unionIndex455 == 1) { + Utf8 charSequence455; + Object oldString455 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(455); + if (oldString455 instanceof Utf8) { + charSequence455 = (decoder).readString(((Utf8) oldString455)); + } else { + charSequence455 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(455, charSequence455); + } else { + throw new RuntimeException(("Illegal union index for 'F455': "+ unionIndex455)); + } + } + int unionIndex456 = (decoder.readIndex()); + if (unionIndex456 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(456, null); + } else { + if (unionIndex456 == 1) { + Utf8 charSequence456; + Object oldString456 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(456); + if (oldString456 instanceof Utf8) { + charSequence456 = (decoder).readString(((Utf8) oldString456)); + } else { + charSequence456 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(456, charSequence456); + } else { + throw new RuntimeException(("Illegal union index for 'F456': "+ unionIndex456)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex457 = (decoder.readIndex()); + if (unionIndex457 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(457, null); + } else { + if (unionIndex457 == 1) { + Utf8 charSequence457; + Object oldString457 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(457); + if (oldString457 instanceof Utf8) { + charSequence457 = (decoder).readString(((Utf8) oldString457)); + } else { + charSequence457 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(457, charSequence457); + } else { + throw new RuntimeException(("Illegal union index for 'F457': "+ unionIndex457)); + } + } + int unionIndex458 = (decoder.readIndex()); + if (unionIndex458 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(458, null); + } else { + if (unionIndex458 == 1) { + Utf8 charSequence458; + Object oldString458 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(458); + if (oldString458 instanceof Utf8) { + charSequence458 = (decoder).readString(((Utf8) oldString458)); + } else { + charSequence458 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(458, charSequence458); + } else { + throw new RuntimeException(("Illegal union index for 'F458': "+ unionIndex458)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex459 = (decoder.readIndex()); + if (unionIndex459 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(459, null); + } else { + if (unionIndex459 == 1) { + Utf8 charSequence459; + Object oldString459 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(459); + if (oldString459 instanceof Utf8) { + charSequence459 = (decoder).readString(((Utf8) oldString459)); + } else { + charSequence459 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(459, charSequence459); + } else { + throw new RuntimeException(("Illegal union index for 'F459': "+ unionIndex459)); + } + } + int unionIndex460 = (decoder.readIndex()); + if (unionIndex460 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(460, null); + } else { + if (unionIndex460 == 1) { + Utf8 charSequence460; + Object oldString460 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(460); + if (oldString460 instanceof Utf8) { + charSequence460 = (decoder).readString(((Utf8) oldString460)); + } else { + charSequence460 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(460, charSequence460); + } else { + throw new RuntimeException(("Illegal union index for 'F460': "+ unionIndex460)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex461 = (decoder.readIndex()); + if (unionIndex461 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(461, null); + } else { + if (unionIndex461 == 1) { + Utf8 charSequence461; + Object oldString461 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(461); + if (oldString461 instanceof Utf8) { + charSequence461 = (decoder).readString(((Utf8) oldString461)); + } else { + charSequence461 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(461, charSequence461); + } else { + throw new RuntimeException(("Illegal union index for 'F461': "+ unionIndex461)); + } + } + int unionIndex462 = (decoder.readIndex()); + if (unionIndex462 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(462, null); + } else { + if (unionIndex462 == 1) { + Utf8 charSequence462; + Object oldString462 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(462); + if (oldString462 instanceof Utf8) { + charSequence462 = (decoder).readString(((Utf8) oldString462)); + } else { + charSequence462 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(462, charSequence462); + } else { + throw new RuntimeException(("Illegal union index for 'F462': "+ unionIndex462)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex463 = (decoder.readIndex()); + if (unionIndex463 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(463, null); + } else { + if (unionIndex463 == 1) { + Utf8 charSequence463; + Object oldString463 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(463); + if (oldString463 instanceof Utf8) { + charSequence463 = (decoder).readString(((Utf8) oldString463)); + } else { + charSequence463 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(463, charSequence463); + } else { + throw new RuntimeException(("Illegal union index for 'F463': "+ unionIndex463)); + } + } + int unionIndex464 = (decoder.readIndex()); + if (unionIndex464 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(464, null); + } else { + if (unionIndex464 == 1) { + Utf8 charSequence464; + Object oldString464 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(464); + if (oldString464 instanceof Utf8) { + charSequence464 = (decoder).readString(((Utf8) oldString464)); + } else { + charSequence464 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(464, charSequence464); + } else { + throw new RuntimeException(("Illegal union index for 'F464': "+ unionIndex464)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex465 = (decoder.readIndex()); + if (unionIndex465 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(465, null); + } else { + if (unionIndex465 == 1) { + Utf8 charSequence465; + Object oldString465 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(465); + if (oldString465 instanceof Utf8) { + charSequence465 = (decoder).readString(((Utf8) oldString465)); + } else { + charSequence465 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(465, charSequence465); + } else { + throw new RuntimeException(("Illegal union index for 'F465': "+ unionIndex465)); + } + } + int unionIndex466 = (decoder.readIndex()); + if (unionIndex466 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(466, null); + } else { + if (unionIndex466 == 1) { + Utf8 charSequence466; + Object oldString466 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(466); + if (oldString466 instanceof Utf8) { + charSequence466 = (decoder).readString(((Utf8) oldString466)); + } else { + charSequence466 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(466, charSequence466); + } else { + throw new RuntimeException(("Illegal union index for 'F466': "+ unionIndex466)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex467 = (decoder.readIndex()); + if (unionIndex467 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(467, null); + } else { + if (unionIndex467 == 1) { + Utf8 charSequence467; + Object oldString467 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(467); + if (oldString467 instanceof Utf8) { + charSequence467 = (decoder).readString(((Utf8) oldString467)); + } else { + charSequence467 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(467, charSequence467); + } else { + throw new RuntimeException(("Illegal union index for 'F467': "+ unionIndex467)); + } + } + int unionIndex468 = (decoder.readIndex()); + if (unionIndex468 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(468, null); + } else { + if (unionIndex468 == 1) { + Utf8 charSequence468; + Object oldString468 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(468); + if (oldString468 instanceof Utf8) { + charSequence468 = (decoder).readString(((Utf8) oldString468)); + } else { + charSequence468 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(468, charSequence468); + } else { + throw new RuntimeException(("Illegal union index for 'F468': "+ unionIndex468)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex469 = (decoder.readIndex()); + if (unionIndex469 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(469, null); + } else { + if (unionIndex469 == 1) { + Utf8 charSequence469; + Object oldString469 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(469); + if (oldString469 instanceof Utf8) { + charSequence469 = (decoder).readString(((Utf8) oldString469)); + } else { + charSequence469 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(469, charSequence469); + } else { + throw new RuntimeException(("Illegal union index for 'F469': "+ unionIndex469)); + } + } + int unionIndex470 = (decoder.readIndex()); + if (unionIndex470 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(470, null); + } else { + if (unionIndex470 == 1) { + Utf8 charSequence470; + Object oldString470 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(470); + if (oldString470 instanceof Utf8) { + charSequence470 = (decoder).readString(((Utf8) oldString470)); + } else { + charSequence470 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(470, charSequence470); + } else { + throw new RuntimeException(("Illegal union index for 'F470': "+ unionIndex470)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex471 = (decoder.readIndex()); + if (unionIndex471 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(471, null); + } else { + if (unionIndex471 == 1) { + Utf8 charSequence471; + Object oldString471 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(471); + if (oldString471 instanceof Utf8) { + charSequence471 = (decoder).readString(((Utf8) oldString471)); + } else { + charSequence471 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(471, charSequence471); + } else { + throw new RuntimeException(("Illegal union index for 'F471': "+ unionIndex471)); + } + } + int unionIndex472 = (decoder.readIndex()); + if (unionIndex472 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(472, null); + } else { + if (unionIndex472 == 1) { + Utf8 charSequence472; + Object oldString472 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(472); + if (oldString472 instanceof Utf8) { + charSequence472 = (decoder).readString(((Utf8) oldString472)); + } else { + charSequence472 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(472, charSequence472); + } else { + throw new RuntimeException(("Illegal union index for 'F472': "+ unionIndex472)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex473 = (decoder.readIndex()); + if (unionIndex473 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(473, null); + } else { + if (unionIndex473 == 1) { + Utf8 charSequence473; + Object oldString473 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(473); + if (oldString473 instanceof Utf8) { + charSequence473 = (decoder).readString(((Utf8) oldString473)); + } else { + charSequence473 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(473, charSequence473); + } else { + throw new RuntimeException(("Illegal union index for 'F473': "+ unionIndex473)); + } + } + int unionIndex474 = (decoder.readIndex()); + if (unionIndex474 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(474, null); + } else { + if (unionIndex474 == 1) { + Utf8 charSequence474; + Object oldString474 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(474); + if (oldString474 instanceof Utf8) { + charSequence474 = (decoder).readString(((Utf8) oldString474)); + } else { + charSequence474 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(474, charSequence474); + } else { + throw new RuntimeException(("Illegal union index for 'F474': "+ unionIndex474)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex475 = (decoder.readIndex()); + if (unionIndex475 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(475, null); + } else { + if (unionIndex475 == 1) { + Utf8 charSequence475; + Object oldString475 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(475); + if (oldString475 instanceof Utf8) { + charSequence475 = (decoder).readString(((Utf8) oldString475)); + } else { + charSequence475 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(475, charSequence475); + } else { + throw new RuntimeException(("Illegal union index for 'F475': "+ unionIndex475)); + } + } + int unionIndex476 = (decoder.readIndex()); + if (unionIndex476 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(476, null); + } else { + if (unionIndex476 == 1) { + Utf8 charSequence476; + Object oldString476 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(476); + if (oldString476 instanceof Utf8) { + charSequence476 = (decoder).readString(((Utf8) oldString476)); + } else { + charSequence476 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(476, charSequence476); + } else { + throw new RuntimeException(("Illegal union index for 'F476': "+ unionIndex476)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex477 = (decoder.readIndex()); + if (unionIndex477 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(477, null); + } else { + if (unionIndex477 == 1) { + Utf8 charSequence477; + Object oldString477 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(477); + if (oldString477 instanceof Utf8) { + charSequence477 = (decoder).readString(((Utf8) oldString477)); + } else { + charSequence477 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(477, charSequence477); + } else { + throw new RuntimeException(("Illegal union index for 'F477': "+ unionIndex477)); + } + } + int unionIndex478 = (decoder.readIndex()); + if (unionIndex478 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(478, null); + } else { + if (unionIndex478 == 1) { + Utf8 charSequence478; + Object oldString478 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(478); + if (oldString478 instanceof Utf8) { + charSequence478 = (decoder).readString(((Utf8) oldString478)); + } else { + charSequence478 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(478, charSequence478); + } else { + throw new RuntimeException(("Illegal union index for 'F478': "+ unionIndex478)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex479 = (decoder.readIndex()); + if (unionIndex479 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(479, null); + } else { + if (unionIndex479 == 1) { + Utf8 charSequence479; + Object oldString479 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(479); + if (oldString479 instanceof Utf8) { + charSequence479 = (decoder).readString(((Utf8) oldString479)); + } else { + charSequence479 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(479, charSequence479); + } else { + throw new RuntimeException(("Illegal union index for 'F479': "+ unionIndex479)); + } + } + int unionIndex480 = (decoder.readIndex()); + if (unionIndex480 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(480, null); + } else { + if (unionIndex480 == 1) { + Utf8 charSequence480; + Object oldString480 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(480); + if (oldString480 instanceof Utf8) { + charSequence480 = (decoder).readString(((Utf8) oldString480)); + } else { + charSequence480 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(480, charSequence480); + } else { + throw new RuntimeException(("Illegal union index for 'F480': "+ unionIndex480)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex481 = (decoder.readIndex()); + if (unionIndex481 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(481, null); + } else { + if (unionIndex481 == 1) { + Utf8 charSequence481; + Object oldString481 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(481); + if (oldString481 instanceof Utf8) { + charSequence481 = (decoder).readString(((Utf8) oldString481)); + } else { + charSequence481 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(481, charSequence481); + } else { + throw new RuntimeException(("Illegal union index for 'F481': "+ unionIndex481)); + } + } + int unionIndex482 = (decoder.readIndex()); + if (unionIndex482 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(482, null); + } else { + if (unionIndex482 == 1) { + Utf8 charSequence482; + Object oldString482 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(482); + if (oldString482 instanceof Utf8) { + charSequence482 = (decoder).readString(((Utf8) oldString482)); + } else { + charSequence482 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(482, charSequence482); + } else { + throw new RuntimeException(("Illegal union index for 'F482': "+ unionIndex482)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex483 = (decoder.readIndex()); + if (unionIndex483 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(483, null); + } else { + if (unionIndex483 == 1) { + Utf8 charSequence483; + Object oldString483 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(483); + if (oldString483 instanceof Utf8) { + charSequence483 = (decoder).readString(((Utf8) oldString483)); + } else { + charSequence483 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(483, charSequence483); + } else { + throw new RuntimeException(("Illegal union index for 'F483': "+ unionIndex483)); + } + } + int unionIndex484 = (decoder.readIndex()); + if (unionIndex484 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(484, null); + } else { + if (unionIndex484 == 1) { + Utf8 charSequence484; + Object oldString484 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(484); + if (oldString484 instanceof Utf8) { + charSequence484 = (decoder).readString(((Utf8) oldString484)); + } else { + charSequence484 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(484, charSequence484); + } else { + throw new RuntimeException(("Illegal union index for 'F484': "+ unionIndex484)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex485 = (decoder.readIndex()); + if (unionIndex485 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(485, null); + } else { + if (unionIndex485 == 1) { + Utf8 charSequence485; + Object oldString485 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(485); + if (oldString485 instanceof Utf8) { + charSequence485 = (decoder).readString(((Utf8) oldString485)); + } else { + charSequence485 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(485, charSequence485); + } else { + throw new RuntimeException(("Illegal union index for 'F485': "+ unionIndex485)); + } + } + int unionIndex486 = (decoder.readIndex()); + if (unionIndex486 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(486, null); + } else { + if (unionIndex486 == 1) { + Utf8 charSequence486; + Object oldString486 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(486); + if (oldString486 instanceof Utf8) { + charSequence486 = (decoder).readString(((Utf8) oldString486)); + } else { + charSequence486 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(486, charSequence486); + } else { + throw new RuntimeException(("Illegal union index for 'F486': "+ unionIndex486)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex487 = (decoder.readIndex()); + if (unionIndex487 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(487, null); + } else { + if (unionIndex487 == 1) { + Utf8 charSequence487; + Object oldString487 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(487); + if (oldString487 instanceof Utf8) { + charSequence487 = (decoder).readString(((Utf8) oldString487)); + } else { + charSequence487 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(487, charSequence487); + } else { + throw new RuntimeException(("Illegal union index for 'F487': "+ unionIndex487)); + } + } + int unionIndex488 = (decoder.readIndex()); + if (unionIndex488 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(488, null); + } else { + if (unionIndex488 == 1) { + Utf8 charSequence488; + Object oldString488 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(488); + if (oldString488 instanceof Utf8) { + charSequence488 = (decoder).readString(((Utf8) oldString488)); + } else { + charSequence488 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(488, charSequence488); + } else { + throw new RuntimeException(("Illegal union index for 'F488': "+ unionIndex488)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex489 = (decoder.readIndex()); + if (unionIndex489 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(489, null); + } else { + if (unionIndex489 == 1) { + Utf8 charSequence489; + Object oldString489 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(489); + if (oldString489 instanceof Utf8) { + charSequence489 = (decoder).readString(((Utf8) oldString489)); + } else { + charSequence489 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(489, charSequence489); + } else { + throw new RuntimeException(("Illegal union index for 'F489': "+ unionIndex489)); + } + } + int unionIndex490 = (decoder.readIndex()); + if (unionIndex490 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(490, null); + } else { + if (unionIndex490 == 1) { + Utf8 charSequence490; + Object oldString490 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(490); + if (oldString490 instanceof Utf8) { + charSequence490 = (decoder).readString(((Utf8) oldString490)); + } else { + charSequence490 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(490, charSequence490); + } else { + throw new RuntimeException(("Illegal union index for 'F490': "+ unionIndex490)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex491 = (decoder.readIndex()); + if (unionIndex491 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(491, null); + } else { + if (unionIndex491 == 1) { + Utf8 charSequence491; + Object oldString491 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(491); + if (oldString491 instanceof Utf8) { + charSequence491 = (decoder).readString(((Utf8) oldString491)); + } else { + charSequence491 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(491, charSequence491); + } else { + throw new RuntimeException(("Illegal union index for 'F491': "+ unionIndex491)); + } + } + int unionIndex492 = (decoder.readIndex()); + if (unionIndex492 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(492, null); + } else { + if (unionIndex492 == 1) { + Utf8 charSequence492; + Object oldString492 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(492); + if (oldString492 instanceof Utf8) { + charSequence492 = (decoder).readString(((Utf8) oldString492)); + } else { + charSequence492 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(492, charSequence492); + } else { + throw new RuntimeException(("Illegal union index for 'F492': "+ unionIndex492)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex493 = (decoder.readIndex()); + if (unionIndex493 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(493, null); + } else { + if (unionIndex493 == 1) { + Utf8 charSequence493; + Object oldString493 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(493); + if (oldString493 instanceof Utf8) { + charSequence493 = (decoder).readString(((Utf8) oldString493)); + } else { + charSequence493 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(493, charSequence493); + } else { + throw new RuntimeException(("Illegal union index for 'F493': "+ unionIndex493)); + } + } + int unionIndex494 = (decoder.readIndex()); + if (unionIndex494 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(494, null); + } else { + if (unionIndex494 == 1) { + Utf8 charSequence494; + Object oldString494 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(494); + if (oldString494 instanceof Utf8) { + charSequence494 = (decoder).readString(((Utf8) oldString494)); + } else { + charSequence494 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(494, charSequence494); + } else { + throw new RuntimeException(("Illegal union index for 'F494': "+ unionIndex494)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex495 = (decoder.readIndex()); + if (unionIndex495 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(495, null); + } else { + if (unionIndex495 == 1) { + Utf8 charSequence495; + Object oldString495 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(495); + if (oldString495 instanceof Utf8) { + charSequence495 = (decoder).readString(((Utf8) oldString495)); + } else { + charSequence495 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(495, charSequence495); + } else { + throw new RuntimeException(("Illegal union index for 'F495': "+ unionIndex495)); + } + } + int unionIndex496 = (decoder.readIndex()); + if (unionIndex496 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(496, null); + } else { + if (unionIndex496 == 1) { + Utf8 charSequence496; + Object oldString496 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(496); + if (oldString496 instanceof Utf8) { + charSequence496 = (decoder).readString(((Utf8) oldString496)); + } else { + charSequence496 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(496, charSequence496); + } else { + throw new RuntimeException(("Illegal union index for 'F496': "+ unionIndex496)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex497 = (decoder.readIndex()); + if (unionIndex497 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(497, null); + } else { + if (unionIndex497 == 1) { + Utf8 charSequence497; + Object oldString497 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(497); + if (oldString497 instanceof Utf8) { + charSequence497 = (decoder).readString(((Utf8) oldString497)); + } else { + charSequence497 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(497, charSequence497); + } else { + throw new RuntimeException(("Illegal union index for 'F497': "+ unionIndex497)); + } + } + int unionIndex498 = (decoder.readIndex()); + if (unionIndex498 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(498, null); + } else { + if (unionIndex498 == 1) { + Utf8 charSequence498; + Object oldString498 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(498); + if (oldString498 instanceof Utf8) { + charSequence498 = (decoder).readString(((Utf8) oldString498)); + } else { + charSequence498 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(498, charSequence498); + } else { + throw new RuntimeException(("Illegal union index for 'F498': "+ unionIndex498)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex499 = (decoder.readIndex()); + if (unionIndex499 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(499, null); + } else { + if (unionIndex499 == 1) { + Utf8 charSequence499; + Object oldString499 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(499); + if (oldString499 instanceof Utf8) { + charSequence499 = (decoder).readString(((Utf8) oldString499)); + } else { + charSequence499 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(499, charSequence499); + } else { + throw new RuntimeException(("Illegal union index for 'F499': "+ unionIndex499)); + } + } + int unionIndex500 = (decoder.readIndex()); + if (unionIndex500 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(500, null); + } else { + if (unionIndex500 == 1) { + Utf8 charSequence500; + Object oldString500 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(500); + if (oldString500 instanceof Utf8) { + charSequence500 = (decoder).readString(((Utf8) oldString500)); + } else { + charSequence500 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(500, charSequence500); + } else { + throw new RuntimeException(("Illegal union index for 'F500': "+ unionIndex500)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex501 = (decoder.readIndex()); + if (unionIndex501 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(501, null); + } else { + if (unionIndex501 == 1) { + Utf8 charSequence501; + Object oldString501 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(501); + if (oldString501 instanceof Utf8) { + charSequence501 = (decoder).readString(((Utf8) oldString501)); + } else { + charSequence501 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(501, charSequence501); + } else { + throw new RuntimeException(("Illegal union index for 'F501': "+ unionIndex501)); + } + } + int unionIndex502 = (decoder.readIndex()); + if (unionIndex502 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(502, null); + } else { + if (unionIndex502 == 1) { + Utf8 charSequence502; + Object oldString502 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(502); + if (oldString502 instanceof Utf8) { + charSequence502 = (decoder).readString(((Utf8) oldString502)); + } else { + charSequence502 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(502, charSequence502); + } else { + throw new RuntimeException(("Illegal union index for 'F502': "+ unionIndex502)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex503 = (decoder.readIndex()); + if (unionIndex503 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(503, null); + } else { + if (unionIndex503 == 1) { + Utf8 charSequence503; + Object oldString503 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(503); + if (oldString503 instanceof Utf8) { + charSequence503 = (decoder).readString(((Utf8) oldString503)); + } else { + charSequence503 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(503, charSequence503); + } else { + throw new RuntimeException(("Illegal union index for 'F503': "+ unionIndex503)); + } + } + int unionIndex504 = (decoder.readIndex()); + if (unionIndex504 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(504, null); + } else { + if (unionIndex504 == 1) { + Utf8 charSequence504; + Object oldString504 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(504); + if (oldString504 instanceof Utf8) { + charSequence504 = (decoder).readString(((Utf8) oldString504)); + } else { + charSequence504 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(504, charSequence504); + } else { + throw new RuntimeException(("Illegal union index for 'F504': "+ unionIndex504)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex505 = (decoder.readIndex()); + if (unionIndex505 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(505, null); + } else { + if (unionIndex505 == 1) { + Utf8 charSequence505; + Object oldString505 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(505); + if (oldString505 instanceof Utf8) { + charSequence505 = (decoder).readString(((Utf8) oldString505)); + } else { + charSequence505 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(505, charSequence505); + } else { + throw new RuntimeException(("Illegal union index for 'F505': "+ unionIndex505)); + } + } + int unionIndex506 = (decoder.readIndex()); + if (unionIndex506 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(506, null); + } else { + if (unionIndex506 == 1) { + Utf8 charSequence506; + Object oldString506 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(506); + if (oldString506 instanceof Utf8) { + charSequence506 = (decoder).readString(((Utf8) oldString506)); + } else { + charSequence506 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(506, charSequence506); + } else { + throw new RuntimeException(("Illegal union index for 'F506': "+ unionIndex506)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex507 = (decoder.readIndex()); + if (unionIndex507 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(507, null); + } else { + if (unionIndex507 == 1) { + Utf8 charSequence507; + Object oldString507 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(507); + if (oldString507 instanceof Utf8) { + charSequence507 = (decoder).readString(((Utf8) oldString507)); + } else { + charSequence507 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(507, charSequence507); + } else { + throw new RuntimeException(("Illegal union index for 'F507': "+ unionIndex507)); + } + } + int unionIndex508 = (decoder.readIndex()); + if (unionIndex508 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(508, null); + } else { + if (unionIndex508 == 1) { + Utf8 charSequence508; + Object oldString508 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(508); + if (oldString508 instanceof Utf8) { + charSequence508 = (decoder).readString(((Utf8) oldString508)); + } else { + charSequence508 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(508, charSequence508); + } else { + throw new RuntimeException(("Illegal union index for 'F508': "+ unionIndex508)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex509 = (decoder.readIndex()); + if (unionIndex509 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(509, null); + } else { + if (unionIndex509 == 1) { + Utf8 charSequence509; + Object oldString509 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(509); + if (oldString509 instanceof Utf8) { + charSequence509 = (decoder).readString(((Utf8) oldString509)); + } else { + charSequence509 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(509, charSequence509); + } else { + throw new RuntimeException(("Illegal union index for 'F509': "+ unionIndex509)); + } + } + int unionIndex510 = (decoder.readIndex()); + if (unionIndex510 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(510, null); + } else { + if (unionIndex510 == 1) { + Utf8 charSequence510; + Object oldString510 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(510); + if (oldString510 instanceof Utf8) { + charSequence510 = (decoder).readString(((Utf8) oldString510)); + } else { + charSequence510 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(510, charSequence510); + } else { + throw new RuntimeException(("Illegal union index for 'F510': "+ unionIndex510)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex511 = (decoder.readIndex()); + if (unionIndex511 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(511, null); + } else { + if (unionIndex511 == 1) { + Utf8 charSequence511; + Object oldString511 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(511); + if (oldString511 instanceof Utf8) { + charSequence511 = (decoder).readString(((Utf8) oldString511)); + } else { + charSequence511 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(511, charSequence511); + } else { + throw new RuntimeException(("Illegal union index for 'F511': "+ unionIndex511)); + } + } + int unionIndex512 = (decoder.readIndex()); + if (unionIndex512 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(512, null); + } else { + if (unionIndex512 == 1) { + Utf8 charSequence512; + Object oldString512 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(512); + if (oldString512 instanceof Utf8) { + charSequence512 = (decoder).readString(((Utf8) oldString512)); + } else { + charSequence512 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(512, charSequence512); + } else { + throw new RuntimeException(("Illegal union index for 'F512': "+ unionIndex512)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex513 = (decoder.readIndex()); + if (unionIndex513 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(513, null); + } else { + if (unionIndex513 == 1) { + Utf8 charSequence513; + Object oldString513 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(513); + if (oldString513 instanceof Utf8) { + charSequence513 = (decoder).readString(((Utf8) oldString513)); + } else { + charSequence513 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(513, charSequence513); + } else { + throw new RuntimeException(("Illegal union index for 'F513': "+ unionIndex513)); + } + } + int unionIndex514 = (decoder.readIndex()); + if (unionIndex514 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(514, null); + } else { + if (unionIndex514 == 1) { + Utf8 charSequence514; + Object oldString514 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(514); + if (oldString514 instanceof Utf8) { + charSequence514 = (decoder).readString(((Utf8) oldString514)); + } else { + charSequence514 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(514, charSequence514); + } else { + throw new RuntimeException(("Illegal union index for 'F514': "+ unionIndex514)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex515 = (decoder.readIndex()); + if (unionIndex515 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(515, null); + } else { + if (unionIndex515 == 1) { + Utf8 charSequence515; + Object oldString515 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(515); + if (oldString515 instanceof Utf8) { + charSequence515 = (decoder).readString(((Utf8) oldString515)); + } else { + charSequence515 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(515, charSequence515); + } else { + throw new RuntimeException(("Illegal union index for 'F515': "+ unionIndex515)); + } + } + int unionIndex516 = (decoder.readIndex()); + if (unionIndex516 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(516, null); + } else { + if (unionIndex516 == 1) { + Utf8 charSequence516; + Object oldString516 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(516); + if (oldString516 instanceof Utf8) { + charSequence516 = (decoder).readString(((Utf8) oldString516)); + } else { + charSequence516 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(516, charSequence516); + } else { + throw new RuntimeException(("Illegal union index for 'F516': "+ unionIndex516)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex517 = (decoder.readIndex()); + if (unionIndex517 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(517, null); + } else { + if (unionIndex517 == 1) { + Utf8 charSequence517; + Object oldString517 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(517); + if (oldString517 instanceof Utf8) { + charSequence517 = (decoder).readString(((Utf8) oldString517)); + } else { + charSequence517 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(517, charSequence517); + } else { + throw new RuntimeException(("Illegal union index for 'F517': "+ unionIndex517)); + } + } + int unionIndex518 = (decoder.readIndex()); + if (unionIndex518 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(518, null); + } else { + if (unionIndex518 == 1) { + Utf8 charSequence518; + Object oldString518 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(518); + if (oldString518 instanceof Utf8) { + charSequence518 = (decoder).readString(((Utf8) oldString518)); + } else { + charSequence518 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(518, charSequence518); + } else { + throw new RuntimeException(("Illegal union index for 'F518': "+ unionIndex518)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex519 = (decoder.readIndex()); + if (unionIndex519 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(519, null); + } else { + if (unionIndex519 == 1) { + Utf8 charSequence519; + Object oldString519 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(519); + if (oldString519 instanceof Utf8) { + charSequence519 = (decoder).readString(((Utf8) oldString519)); + } else { + charSequence519 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(519, charSequence519); + } else { + throw new RuntimeException(("Illegal union index for 'F519': "+ unionIndex519)); + } + } + int unionIndex520 = (decoder.readIndex()); + if (unionIndex520 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(520, null); + } else { + if (unionIndex520 == 1) { + Utf8 charSequence520; + Object oldString520 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(520); + if (oldString520 instanceof Utf8) { + charSequence520 = (decoder).readString(((Utf8) oldString520)); + } else { + charSequence520 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(520, charSequence520); + } else { + throw new RuntimeException(("Illegal union index for 'F520': "+ unionIndex520)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex521 = (decoder.readIndex()); + if (unionIndex521 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(521, null); + } else { + if (unionIndex521 == 1) { + Utf8 charSequence521; + Object oldString521 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(521); + if (oldString521 instanceof Utf8) { + charSequence521 = (decoder).readString(((Utf8) oldString521)); + } else { + charSequence521 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(521, charSequence521); + } else { + throw new RuntimeException(("Illegal union index for 'F521': "+ unionIndex521)); + } + } + int unionIndex522 = (decoder.readIndex()); + if (unionIndex522 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(522, null); + } else { + if (unionIndex522 == 1) { + Utf8 charSequence522; + Object oldString522 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(522); + if (oldString522 instanceof Utf8) { + charSequence522 = (decoder).readString(((Utf8) oldString522)); + } else { + charSequence522 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(522, charSequence522); + } else { + throw new RuntimeException(("Illegal union index for 'F522': "+ unionIndex522)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex523 = (decoder.readIndex()); + if (unionIndex523 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(523, null); + } else { + if (unionIndex523 == 1) { + Utf8 charSequence523; + Object oldString523 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(523); + if (oldString523 instanceof Utf8) { + charSequence523 = (decoder).readString(((Utf8) oldString523)); + } else { + charSequence523 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(523, charSequence523); + } else { + throw new RuntimeException(("Illegal union index for 'F523': "+ unionIndex523)); + } + } + int unionIndex524 = (decoder.readIndex()); + if (unionIndex524 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(524, null); + } else { + if (unionIndex524 == 1) { + Utf8 charSequence524; + Object oldString524 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(524); + if (oldString524 instanceof Utf8) { + charSequence524 = (decoder).readString(((Utf8) oldString524)); + } else { + charSequence524 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(524, charSequence524); + } else { + throw new RuntimeException(("Illegal union index for 'F524': "+ unionIndex524)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex525 = (decoder.readIndex()); + if (unionIndex525 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(525, null); + } else { + if (unionIndex525 == 1) { + Utf8 charSequence525; + Object oldString525 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(525); + if (oldString525 instanceof Utf8) { + charSequence525 = (decoder).readString(((Utf8) oldString525)); + } else { + charSequence525 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(525, charSequence525); + } else { + throw new RuntimeException(("Illegal union index for 'F525': "+ unionIndex525)); + } + } + int unionIndex526 = (decoder.readIndex()); + if (unionIndex526 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(526, null); + } else { + if (unionIndex526 == 1) { + Utf8 charSequence526; + Object oldString526 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(526); + if (oldString526 instanceof Utf8) { + charSequence526 = (decoder).readString(((Utf8) oldString526)); + } else { + charSequence526 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(526, charSequence526); + } else { + throw new RuntimeException(("Illegal union index for 'F526': "+ unionIndex526)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex527 = (decoder.readIndex()); + if (unionIndex527 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(527, null); + } else { + if (unionIndex527 == 1) { + Utf8 charSequence527; + Object oldString527 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(527); + if (oldString527 instanceof Utf8) { + charSequence527 = (decoder).readString(((Utf8) oldString527)); + } else { + charSequence527 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(527, charSequence527); + } else { + throw new RuntimeException(("Illegal union index for 'F527': "+ unionIndex527)); + } + } + int unionIndex528 = (decoder.readIndex()); + if (unionIndex528 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(528, null); + } else { + if (unionIndex528 == 1) { + Utf8 charSequence528; + Object oldString528 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(528); + if (oldString528 instanceof Utf8) { + charSequence528 = (decoder).readString(((Utf8) oldString528)); + } else { + charSequence528 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(528, charSequence528); + } else { + throw new RuntimeException(("Illegal union index for 'F528': "+ unionIndex528)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex529 = (decoder.readIndex()); + if (unionIndex529 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(529, null); + } else { + if (unionIndex529 == 1) { + Utf8 charSequence529; + Object oldString529 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(529); + if (oldString529 instanceof Utf8) { + charSequence529 = (decoder).readString(((Utf8) oldString529)); + } else { + charSequence529 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(529, charSequence529); + } else { + throw new RuntimeException(("Illegal union index for 'F529': "+ unionIndex529)); + } + } + int unionIndex530 = (decoder.readIndex()); + if (unionIndex530 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(530, null); + } else { + if (unionIndex530 == 1) { + Utf8 charSequence530; + Object oldString530 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(530); + if (oldString530 instanceof Utf8) { + charSequence530 = (decoder).readString(((Utf8) oldString530)); + } else { + charSequence530 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(530, charSequence530); + } else { + throw new RuntimeException(("Illegal union index for 'F530': "+ unionIndex530)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex531 = (decoder.readIndex()); + if (unionIndex531 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(531, null); + } else { + if (unionIndex531 == 1) { + Utf8 charSequence531; + Object oldString531 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(531); + if (oldString531 instanceof Utf8) { + charSequence531 = (decoder).readString(((Utf8) oldString531)); + } else { + charSequence531 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(531, charSequence531); + } else { + throw new RuntimeException(("Illegal union index for 'F531': "+ unionIndex531)); + } + } + int unionIndex532 = (decoder.readIndex()); + if (unionIndex532 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(532, null); + } else { + if (unionIndex532 == 1) { + Utf8 charSequence532; + Object oldString532 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(532); + if (oldString532 instanceof Utf8) { + charSequence532 = (decoder).readString(((Utf8) oldString532)); + } else { + charSequence532 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(532, charSequence532); + } else { + throw new RuntimeException(("Illegal union index for 'F532': "+ unionIndex532)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex533 = (decoder.readIndex()); + if (unionIndex533 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(533, null); + } else { + if (unionIndex533 == 1) { + Utf8 charSequence533; + Object oldString533 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(533); + if (oldString533 instanceof Utf8) { + charSequence533 = (decoder).readString(((Utf8) oldString533)); + } else { + charSequence533 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(533, charSequence533); + } else { + throw new RuntimeException(("Illegal union index for 'F533': "+ unionIndex533)); + } + } + int unionIndex534 = (decoder.readIndex()); + if (unionIndex534 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(534, null); + } else { + if (unionIndex534 == 1) { + Utf8 charSequence534; + Object oldString534 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(534); + if (oldString534 instanceof Utf8) { + charSequence534 = (decoder).readString(((Utf8) oldString534)); + } else { + charSequence534 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(534, charSequence534); + } else { + throw new RuntimeException(("Illegal union index for 'F534': "+ unionIndex534)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex535 = (decoder.readIndex()); + if (unionIndex535 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(535, null); + } else { + if (unionIndex535 == 1) { + Utf8 charSequence535; + Object oldString535 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(535); + if (oldString535 instanceof Utf8) { + charSequence535 = (decoder).readString(((Utf8) oldString535)); + } else { + charSequence535 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(535, charSequence535); + } else { + throw new RuntimeException(("Illegal union index for 'F535': "+ unionIndex535)); + } + } + int unionIndex536 = (decoder.readIndex()); + if (unionIndex536 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(536, null); + } else { + if (unionIndex536 == 1) { + Utf8 charSequence536; + Object oldString536 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(536); + if (oldString536 instanceof Utf8) { + charSequence536 = (decoder).readString(((Utf8) oldString536)); + } else { + charSequence536 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(536, charSequence536); + } else { + throw new RuntimeException(("Illegal union index for 'F536': "+ unionIndex536)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex537 = (decoder.readIndex()); + if (unionIndex537 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(537, null); + } else { + if (unionIndex537 == 1) { + Utf8 charSequence537; + Object oldString537 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(537); + if (oldString537 instanceof Utf8) { + charSequence537 = (decoder).readString(((Utf8) oldString537)); + } else { + charSequence537 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(537, charSequence537); + } else { + throw new RuntimeException(("Illegal union index for 'F537': "+ unionIndex537)); + } + } + int unionIndex538 = (decoder.readIndex()); + if (unionIndex538 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(538, null); + } else { + if (unionIndex538 == 1) { + Utf8 charSequence538; + Object oldString538 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(538); + if (oldString538 instanceof Utf8) { + charSequence538 = (decoder).readString(((Utf8) oldString538)); + } else { + charSequence538 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(538, charSequence538); + } else { + throw new RuntimeException(("Illegal union index for 'F538': "+ unionIndex538)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex539 = (decoder.readIndex()); + if (unionIndex539 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(539, null); + } else { + if (unionIndex539 == 1) { + Utf8 charSequence539; + Object oldString539 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(539); + if (oldString539 instanceof Utf8) { + charSequence539 = (decoder).readString(((Utf8) oldString539)); + } else { + charSequence539 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(539, charSequence539); + } else { + throw new RuntimeException(("Illegal union index for 'F539': "+ unionIndex539)); + } + } + int unionIndex540 = (decoder.readIndex()); + if (unionIndex540 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(540, null); + } else { + if (unionIndex540 == 1) { + Utf8 charSequence540; + Object oldString540 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(540); + if (oldString540 instanceof Utf8) { + charSequence540 = (decoder).readString(((Utf8) oldString540)); + } else { + charSequence540 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(540, charSequence540); + } else { + throw new RuntimeException(("Illegal union index for 'F540': "+ unionIndex540)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex541 = (decoder.readIndex()); + if (unionIndex541 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(541, null); + } else { + if (unionIndex541 == 1) { + Utf8 charSequence541; + Object oldString541 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(541); + if (oldString541 instanceof Utf8) { + charSequence541 = (decoder).readString(((Utf8) oldString541)); + } else { + charSequence541 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(541, charSequence541); + } else { + throw new RuntimeException(("Illegal union index for 'F541': "+ unionIndex541)); + } + } + int unionIndex542 = (decoder.readIndex()); + if (unionIndex542 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(542, null); + } else { + if (unionIndex542 == 1) { + Utf8 charSequence542; + Object oldString542 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(542); + if (oldString542 instanceof Utf8) { + charSequence542 = (decoder).readString(((Utf8) oldString542)); + } else { + charSequence542 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(542, charSequence542); + } else { + throw new RuntimeException(("Illegal union index for 'F542': "+ unionIndex542)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex543 = (decoder.readIndex()); + if (unionIndex543 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(543, null); + } else { + if (unionIndex543 == 1) { + Utf8 charSequence543; + Object oldString543 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(543); + if (oldString543 instanceof Utf8) { + charSequence543 = (decoder).readString(((Utf8) oldString543)); + } else { + charSequence543 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(543, charSequence543); + } else { + throw new RuntimeException(("Illegal union index for 'F543': "+ unionIndex543)); + } + } + int unionIndex544 = (decoder.readIndex()); + if (unionIndex544 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(544, null); + } else { + if (unionIndex544 == 1) { + Utf8 charSequence544; + Object oldString544 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(544); + if (oldString544 instanceof Utf8) { + charSequence544 = (decoder).readString(((Utf8) oldString544)); + } else { + charSequence544 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(544, charSequence544); + } else { + throw new RuntimeException(("Illegal union index for 'F544': "+ unionIndex544)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex545 = (decoder.readIndex()); + if (unionIndex545 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(545, null); + } else { + if (unionIndex545 == 1) { + Utf8 charSequence545; + Object oldString545 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(545); + if (oldString545 instanceof Utf8) { + charSequence545 = (decoder).readString(((Utf8) oldString545)); + } else { + charSequence545 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(545, charSequence545); + } else { + throw new RuntimeException(("Illegal union index for 'F545': "+ unionIndex545)); + } + } + int unionIndex546 = (decoder.readIndex()); + if (unionIndex546 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(546, null); + } else { + if (unionIndex546 == 1) { + Utf8 charSequence546; + Object oldString546 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(546); + if (oldString546 instanceof Utf8) { + charSequence546 = (decoder).readString(((Utf8) oldString546)); + } else { + charSequence546 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(546, charSequence546); + } else { + throw new RuntimeException(("Illegal union index for 'F546': "+ unionIndex546)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex547 = (decoder.readIndex()); + if (unionIndex547 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(547, null); + } else { + if (unionIndex547 == 1) { + Utf8 charSequence547; + Object oldString547 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(547); + if (oldString547 instanceof Utf8) { + charSequence547 = (decoder).readString(((Utf8) oldString547)); + } else { + charSequence547 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(547, charSequence547); + } else { + throw new RuntimeException(("Illegal union index for 'F547': "+ unionIndex547)); + } + } + int unionIndex548 = (decoder.readIndex()); + if (unionIndex548 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(548, null); + } else { + if (unionIndex548 == 1) { + Utf8 charSequence548; + Object oldString548 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(548); + if (oldString548 instanceof Utf8) { + charSequence548 = (decoder).readString(((Utf8) oldString548)); + } else { + charSequence548 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(548, charSequence548); + } else { + throw new RuntimeException(("Illegal union index for 'F548': "+ unionIndex548)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex549 = (decoder.readIndex()); + if (unionIndex549 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(549, null); + } else { + if (unionIndex549 == 1) { + Utf8 charSequence549; + Object oldString549 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(549); + if (oldString549 instanceof Utf8) { + charSequence549 = (decoder).readString(((Utf8) oldString549)); + } else { + charSequence549 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(549, charSequence549); + } else { + throw new RuntimeException(("Illegal union index for 'F549': "+ unionIndex549)); + } + } + int unionIndex550 = (decoder.readIndex()); + if (unionIndex550 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(550, null); + } else { + if (unionIndex550 == 1) { + Utf8 charSequence550; + Object oldString550 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(550); + if (oldString550 instanceof Utf8) { + charSequence550 = (decoder).readString(((Utf8) oldString550)); + } else { + charSequence550 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(550, charSequence550); + } else { + throw new RuntimeException(("Illegal union index for 'F550': "+ unionIndex550)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex551 = (decoder.readIndex()); + if (unionIndex551 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(551, null); + } else { + if (unionIndex551 == 1) { + Utf8 charSequence551; + Object oldString551 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(551); + if (oldString551 instanceof Utf8) { + charSequence551 = (decoder).readString(((Utf8) oldString551)); + } else { + charSequence551 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(551, charSequence551); + } else { + throw new RuntimeException(("Illegal union index for 'F551': "+ unionIndex551)); + } + } + int unionIndex552 = (decoder.readIndex()); + if (unionIndex552 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(552, null); + } else { + if (unionIndex552 == 1) { + Utf8 charSequence552; + Object oldString552 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(552); + if (oldString552 instanceof Utf8) { + charSequence552 = (decoder).readString(((Utf8) oldString552)); + } else { + charSequence552 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(552, charSequence552); + } else { + throw new RuntimeException(("Illegal union index for 'F552': "+ unionIndex552)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex553 = (decoder.readIndex()); + if (unionIndex553 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(553, null); + } else { + if (unionIndex553 == 1) { + Utf8 charSequence553; + Object oldString553 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(553); + if (oldString553 instanceof Utf8) { + charSequence553 = (decoder).readString(((Utf8) oldString553)); + } else { + charSequence553 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(553, charSequence553); + } else { + throw new RuntimeException(("Illegal union index for 'F553': "+ unionIndex553)); + } + } + int unionIndex554 = (decoder.readIndex()); + if (unionIndex554 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(554, null); + } else { + if (unionIndex554 == 1) { + Utf8 charSequence554; + Object oldString554 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(554); + if (oldString554 instanceof Utf8) { + charSequence554 = (decoder).readString(((Utf8) oldString554)); + } else { + charSequence554 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(554, charSequence554); + } else { + throw new RuntimeException(("Illegal union index for 'F554': "+ unionIndex554)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex555 = (decoder.readIndex()); + if (unionIndex555 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(555, null); + } else { + if (unionIndex555 == 1) { + Utf8 charSequence555; + Object oldString555 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(555); + if (oldString555 instanceof Utf8) { + charSequence555 = (decoder).readString(((Utf8) oldString555)); + } else { + charSequence555 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(555, charSequence555); + } else { + throw new RuntimeException(("Illegal union index for 'F555': "+ unionIndex555)); + } + } + int unionIndex556 = (decoder.readIndex()); + if (unionIndex556 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(556, null); + } else { + if (unionIndex556 == 1) { + Utf8 charSequence556; + Object oldString556 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(556); + if (oldString556 instanceof Utf8) { + charSequence556 = (decoder).readString(((Utf8) oldString556)); + } else { + charSequence556 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(556, charSequence556); + } else { + throw new RuntimeException(("Illegal union index for 'F556': "+ unionIndex556)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex557 = (decoder.readIndex()); + if (unionIndex557 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(557, null); + } else { + if (unionIndex557 == 1) { + Utf8 charSequence557; + Object oldString557 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(557); + if (oldString557 instanceof Utf8) { + charSequence557 = (decoder).readString(((Utf8) oldString557)); + } else { + charSequence557 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(557, charSequence557); + } else { + throw new RuntimeException(("Illegal union index for 'F557': "+ unionIndex557)); + } + } + int unionIndex558 = (decoder.readIndex()); + if (unionIndex558 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(558, null); + } else { + if (unionIndex558 == 1) { + Utf8 charSequence558; + Object oldString558 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(558); + if (oldString558 instanceof Utf8) { + charSequence558 = (decoder).readString(((Utf8) oldString558)); + } else { + charSequence558 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(558, charSequence558); + } else { + throw new RuntimeException(("Illegal union index for 'F558': "+ unionIndex558)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex559 = (decoder.readIndex()); + if (unionIndex559 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(559, null); + } else { + if (unionIndex559 == 1) { + Utf8 charSequence559; + Object oldString559 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(559); + if (oldString559 instanceof Utf8) { + charSequence559 = (decoder).readString(((Utf8) oldString559)); + } else { + charSequence559 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(559, charSequence559); + } else { + throw new RuntimeException(("Illegal union index for 'F559': "+ unionIndex559)); + } + } + int unionIndex560 = (decoder.readIndex()); + if (unionIndex560 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(560, null); + } else { + if (unionIndex560 == 1) { + Utf8 charSequence560; + Object oldString560 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(560); + if (oldString560 instanceof Utf8) { + charSequence560 = (decoder).readString(((Utf8) oldString560)); + } else { + charSequence560 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(560, charSequence560); + } else { + throw new RuntimeException(("Illegal union index for 'F560': "+ unionIndex560)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex561 = (decoder.readIndex()); + if (unionIndex561 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(561, null); + } else { + if (unionIndex561 == 1) { + Utf8 charSequence561; + Object oldString561 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(561); + if (oldString561 instanceof Utf8) { + charSequence561 = (decoder).readString(((Utf8) oldString561)); + } else { + charSequence561 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(561, charSequence561); + } else { + throw new RuntimeException(("Illegal union index for 'F561': "+ unionIndex561)); + } + } + int unionIndex562 = (decoder.readIndex()); + if (unionIndex562 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(562, null); + } else { + if (unionIndex562 == 1) { + Utf8 charSequence562; + Object oldString562 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(562); + if (oldString562 instanceof Utf8) { + charSequence562 = (decoder).readString(((Utf8) oldString562)); + } else { + charSequence562 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(562, charSequence562); + } else { + throw new RuntimeException(("Illegal union index for 'F562': "+ unionIndex562)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex563 = (decoder.readIndex()); + if (unionIndex563 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(563, null); + } else { + if (unionIndex563 == 1) { + Utf8 charSequence563; + Object oldString563 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(563); + if (oldString563 instanceof Utf8) { + charSequence563 = (decoder).readString(((Utf8) oldString563)); + } else { + charSequence563 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(563, charSequence563); + } else { + throw new RuntimeException(("Illegal union index for 'F563': "+ unionIndex563)); + } + } + int unionIndex564 = (decoder.readIndex()); + if (unionIndex564 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(564, null); + } else { + if (unionIndex564 == 1) { + Utf8 charSequence564; + Object oldString564 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(564); + if (oldString564 instanceof Utf8) { + charSequence564 = (decoder).readString(((Utf8) oldString564)); + } else { + charSequence564 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(564, charSequence564); + } else { + throw new RuntimeException(("Illegal union index for 'F564': "+ unionIndex564)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex565 = (decoder.readIndex()); + if (unionIndex565 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(565, null); + } else { + if (unionIndex565 == 1) { + Utf8 charSequence565; + Object oldString565 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(565); + if (oldString565 instanceof Utf8) { + charSequence565 = (decoder).readString(((Utf8) oldString565)); + } else { + charSequence565 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(565, charSequence565); + } else { + throw new RuntimeException(("Illegal union index for 'F565': "+ unionIndex565)); + } + } + int unionIndex566 = (decoder.readIndex()); + if (unionIndex566 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(566, null); + } else { + if (unionIndex566 == 1) { + Utf8 charSequence566; + Object oldString566 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(566); + if (oldString566 instanceof Utf8) { + charSequence566 = (decoder).readString(((Utf8) oldString566)); + } else { + charSequence566 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(566, charSequence566); + } else { + throw new RuntimeException(("Illegal union index for 'F566': "+ unionIndex566)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex567 = (decoder.readIndex()); + if (unionIndex567 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(567, null); + } else { + if (unionIndex567 == 1) { + Utf8 charSequence567; + Object oldString567 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(567); + if (oldString567 instanceof Utf8) { + charSequence567 = (decoder).readString(((Utf8) oldString567)); + } else { + charSequence567 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(567, charSequence567); + } else { + throw new RuntimeException(("Illegal union index for 'F567': "+ unionIndex567)); + } + } + int unionIndex568 = (decoder.readIndex()); + if (unionIndex568 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(568, null); + } else { + if (unionIndex568 == 1) { + Utf8 charSequence568; + Object oldString568 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(568); + if (oldString568 instanceof Utf8) { + charSequence568 = (decoder).readString(((Utf8) oldString568)); + } else { + charSequence568 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(568, charSequence568); + } else { + throw new RuntimeException(("Illegal union index for 'F568': "+ unionIndex568)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex569 = (decoder.readIndex()); + if (unionIndex569 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(569, null); + } else { + if (unionIndex569 == 1) { + Utf8 charSequence569; + Object oldString569 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(569); + if (oldString569 instanceof Utf8) { + charSequence569 = (decoder).readString(((Utf8) oldString569)); + } else { + charSequence569 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(569, charSequence569); + } else { + throw new RuntimeException(("Illegal union index for 'F569': "+ unionIndex569)); + } + } + int unionIndex570 = (decoder.readIndex()); + if (unionIndex570 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(570, null); + } else { + if (unionIndex570 == 1) { + Utf8 charSequence570; + Object oldString570 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(570); + if (oldString570 instanceof Utf8) { + charSequence570 = (decoder).readString(((Utf8) oldString570)); + } else { + charSequence570 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(570, charSequence570); + } else { + throw new RuntimeException(("Illegal union index for 'F570': "+ unionIndex570)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex571 = (decoder.readIndex()); + if (unionIndex571 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(571, null); + } else { + if (unionIndex571 == 1) { + Utf8 charSequence571; + Object oldString571 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(571); + if (oldString571 instanceof Utf8) { + charSequence571 = (decoder).readString(((Utf8) oldString571)); + } else { + charSequence571 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(571, charSequence571); + } else { + throw new RuntimeException(("Illegal union index for 'F571': "+ unionIndex571)); + } + } + int unionIndex572 = (decoder.readIndex()); + if (unionIndex572 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(572, null); + } else { + if (unionIndex572 == 1) { + Utf8 charSequence572; + Object oldString572 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(572); + if (oldString572 instanceof Utf8) { + charSequence572 = (decoder).readString(((Utf8) oldString572)); + } else { + charSequence572 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(572, charSequence572); + } else { + throw new RuntimeException(("Illegal union index for 'F572': "+ unionIndex572)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex573 = (decoder.readIndex()); + if (unionIndex573 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(573, null); + } else { + if (unionIndex573 == 1) { + Utf8 charSequence573; + Object oldString573 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(573); + if (oldString573 instanceof Utf8) { + charSequence573 = (decoder).readString(((Utf8) oldString573)); + } else { + charSequence573 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(573, charSequence573); + } else { + throw new RuntimeException(("Illegal union index for 'F573': "+ unionIndex573)); + } + } + int unionIndex574 = (decoder.readIndex()); + if (unionIndex574 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(574, null); + } else { + if (unionIndex574 == 1) { + Utf8 charSequence574; + Object oldString574 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(574); + if (oldString574 instanceof Utf8) { + charSequence574 = (decoder).readString(((Utf8) oldString574)); + } else { + charSequence574 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(574, charSequence574); + } else { + throw new RuntimeException(("Illegal union index for 'F574': "+ unionIndex574)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex575 = (decoder.readIndex()); + if (unionIndex575 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(575, null); + } else { + if (unionIndex575 == 1) { + Utf8 charSequence575; + Object oldString575 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(575); + if (oldString575 instanceof Utf8) { + charSequence575 = (decoder).readString(((Utf8) oldString575)); + } else { + charSequence575 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(575, charSequence575); + } else { + throw new RuntimeException(("Illegal union index for 'F575': "+ unionIndex575)); + } + } + int unionIndex576 = (decoder.readIndex()); + if (unionIndex576 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(576, null); + } else { + if (unionIndex576 == 1) { + Utf8 charSequence576; + Object oldString576 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(576); + if (oldString576 instanceof Utf8) { + charSequence576 = (decoder).readString(((Utf8) oldString576)); + } else { + charSequence576 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(576, charSequence576); + } else { + throw new RuntimeException(("Illegal union index for 'F576': "+ unionIndex576)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex577 = (decoder.readIndex()); + if (unionIndex577 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(577, null); + } else { + if (unionIndex577 == 1) { + Utf8 charSequence577; + Object oldString577 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(577); + if (oldString577 instanceof Utf8) { + charSequence577 = (decoder).readString(((Utf8) oldString577)); + } else { + charSequence577 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(577, charSequence577); + } else { + throw new RuntimeException(("Illegal union index for 'F577': "+ unionIndex577)); + } + } + int unionIndex578 = (decoder.readIndex()); + if (unionIndex578 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(578, null); + } else { + if (unionIndex578 == 1) { + Utf8 charSequence578; + Object oldString578 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(578); + if (oldString578 instanceof Utf8) { + charSequence578 = (decoder).readString(((Utf8) oldString578)); + } else { + charSequence578 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(578, charSequence578); + } else { + throw new RuntimeException(("Illegal union index for 'F578': "+ unionIndex578)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex579 = (decoder.readIndex()); + if (unionIndex579 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(579, null); + } else { + if (unionIndex579 == 1) { + Utf8 charSequence579; + Object oldString579 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(579); + if (oldString579 instanceof Utf8) { + charSequence579 = (decoder).readString(((Utf8) oldString579)); + } else { + charSequence579 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(579, charSequence579); + } else { + throw new RuntimeException(("Illegal union index for 'F579': "+ unionIndex579)); + } + } + int unionIndex580 = (decoder.readIndex()); + if (unionIndex580 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(580, null); + } else { + if (unionIndex580 == 1) { + Utf8 charSequence580; + Object oldString580 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(580); + if (oldString580 instanceof Utf8) { + charSequence580 = (decoder).readString(((Utf8) oldString580)); + } else { + charSequence580 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(580, charSequence580); + } else { + throw new RuntimeException(("Illegal union index for 'F580': "+ unionIndex580)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex581 = (decoder.readIndex()); + if (unionIndex581 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(581, null); + } else { + if (unionIndex581 == 1) { + Utf8 charSequence581; + Object oldString581 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(581); + if (oldString581 instanceof Utf8) { + charSequence581 = (decoder).readString(((Utf8) oldString581)); + } else { + charSequence581 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(581, charSequence581); + } else { + throw new RuntimeException(("Illegal union index for 'F581': "+ unionIndex581)); + } + } + int unionIndex582 = (decoder.readIndex()); + if (unionIndex582 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(582, null); + } else { + if (unionIndex582 == 1) { + Utf8 charSequence582; + Object oldString582 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(582); + if (oldString582 instanceof Utf8) { + charSequence582 = (decoder).readString(((Utf8) oldString582)); + } else { + charSequence582 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(582, charSequence582); + } else { + throw new RuntimeException(("Illegal union index for 'F582': "+ unionIndex582)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex583 = (decoder.readIndex()); + if (unionIndex583 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(583, null); + } else { + if (unionIndex583 == 1) { + Utf8 charSequence583; + Object oldString583 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(583); + if (oldString583 instanceof Utf8) { + charSequence583 = (decoder).readString(((Utf8) oldString583)); + } else { + charSequence583 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(583, charSequence583); + } else { + throw new RuntimeException(("Illegal union index for 'F583': "+ unionIndex583)); + } + } + int unionIndex584 = (decoder.readIndex()); + if (unionIndex584 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(584, null); + } else { + if (unionIndex584 == 1) { + Utf8 charSequence584; + Object oldString584 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(584); + if (oldString584 instanceof Utf8) { + charSequence584 = (decoder).readString(((Utf8) oldString584)); + } else { + charSequence584 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(584, charSequence584); + } else { + throw new RuntimeException(("Illegal union index for 'F584': "+ unionIndex584)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex585 = (decoder.readIndex()); + if (unionIndex585 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(585, null); + } else { + if (unionIndex585 == 1) { + Utf8 charSequence585; + Object oldString585 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(585); + if (oldString585 instanceof Utf8) { + charSequence585 = (decoder).readString(((Utf8) oldString585)); + } else { + charSequence585 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(585, charSequence585); + } else { + throw new RuntimeException(("Illegal union index for 'F585': "+ unionIndex585)); + } + } + int unionIndex586 = (decoder.readIndex()); + if (unionIndex586 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(586, null); + } else { + if (unionIndex586 == 1) { + Utf8 charSequence586; + Object oldString586 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(586); + if (oldString586 instanceof Utf8) { + charSequence586 = (decoder).readString(((Utf8) oldString586)); + } else { + charSequence586 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(586, charSequence586); + } else { + throw new RuntimeException(("Illegal union index for 'F586': "+ unionIndex586)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex587 = (decoder.readIndex()); + if (unionIndex587 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(587, null); + } else { + if (unionIndex587 == 1) { + Utf8 charSequence587; + Object oldString587 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(587); + if (oldString587 instanceof Utf8) { + charSequence587 = (decoder).readString(((Utf8) oldString587)); + } else { + charSequence587 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(587, charSequence587); + } else { + throw new RuntimeException(("Illegal union index for 'F587': "+ unionIndex587)); + } + } + int unionIndex588 = (decoder.readIndex()); + if (unionIndex588 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(588, null); + } else { + if (unionIndex588 == 1) { + Utf8 charSequence588; + Object oldString588 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(588); + if (oldString588 instanceof Utf8) { + charSequence588 = (decoder).readString(((Utf8) oldString588)); + } else { + charSequence588 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(588, charSequence588); + } else { + throw new RuntimeException(("Illegal union index for 'F588': "+ unionIndex588)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex589 = (decoder.readIndex()); + if (unionIndex589 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(589, null); + } else { + if (unionIndex589 == 1) { + Utf8 charSequence589; + Object oldString589 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(589); + if (oldString589 instanceof Utf8) { + charSequence589 = (decoder).readString(((Utf8) oldString589)); + } else { + charSequence589 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(589, charSequence589); + } else { + throw new RuntimeException(("Illegal union index for 'F589': "+ unionIndex589)); + } + } + int unionIndex590 = (decoder.readIndex()); + if (unionIndex590 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(590, null); + } else { + if (unionIndex590 == 1) { + Utf8 charSequence590; + Object oldString590 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(590); + if (oldString590 instanceof Utf8) { + charSequence590 = (decoder).readString(((Utf8) oldString590)); + } else { + charSequence590 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(590, charSequence590); + } else { + throw new RuntimeException(("Illegal union index for 'F590': "+ unionIndex590)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex591 = (decoder.readIndex()); + if (unionIndex591 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(591, null); + } else { + if (unionIndex591 == 1) { + Utf8 charSequence591; + Object oldString591 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(591); + if (oldString591 instanceof Utf8) { + charSequence591 = (decoder).readString(((Utf8) oldString591)); + } else { + charSequence591 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(591, charSequence591); + } else { + throw new RuntimeException(("Illegal union index for 'F591': "+ unionIndex591)); + } + } + int unionIndex592 = (decoder.readIndex()); + if (unionIndex592 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(592, null); + } else { + if (unionIndex592 == 1) { + Utf8 charSequence592; + Object oldString592 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(592); + if (oldString592 instanceof Utf8) { + charSequence592 = (decoder).readString(((Utf8) oldString592)); + } else { + charSequence592 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(592, charSequence592); + } else { + throw new RuntimeException(("Illegal union index for 'F592': "+ unionIndex592)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex593 = (decoder.readIndex()); + if (unionIndex593 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(593, null); + } else { + if (unionIndex593 == 1) { + Utf8 charSequence593; + Object oldString593 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(593); + if (oldString593 instanceof Utf8) { + charSequence593 = (decoder).readString(((Utf8) oldString593)); + } else { + charSequence593 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(593, charSequence593); + } else { + throw new RuntimeException(("Illegal union index for 'F593': "+ unionIndex593)); + } + } + int unionIndex594 = (decoder.readIndex()); + if (unionIndex594 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(594, null); + } else { + if (unionIndex594 == 1) { + Utf8 charSequence594; + Object oldString594 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(594); + if (oldString594 instanceof Utf8) { + charSequence594 = (decoder).readString(((Utf8) oldString594)); + } else { + charSequence594 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(594, charSequence594); + } else { + throw new RuntimeException(("Illegal union index for 'F594': "+ unionIndex594)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex595 = (decoder.readIndex()); + if (unionIndex595 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(595, null); + } else { + if (unionIndex595 == 1) { + Utf8 charSequence595; + Object oldString595 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(595); + if (oldString595 instanceof Utf8) { + charSequence595 = (decoder).readString(((Utf8) oldString595)); + } else { + charSequence595 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(595, charSequence595); + } else { + throw new RuntimeException(("Illegal union index for 'F595': "+ unionIndex595)); + } + } + int unionIndex596 = (decoder.readIndex()); + if (unionIndex596 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(596, null); + } else { + if (unionIndex596 == 1) { + Utf8 charSequence596; + Object oldString596 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(596); + if (oldString596 instanceof Utf8) { + charSequence596 = (decoder).readString(((Utf8) oldString596)); + } else { + charSequence596 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(596, charSequence596); + } else { + throw new RuntimeException(("Illegal union index for 'F596': "+ unionIndex596)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex597 = (decoder.readIndex()); + if (unionIndex597 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(597, null); + } else { + if (unionIndex597 == 1) { + Utf8 charSequence597; + Object oldString597 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(597); + if (oldString597 instanceof Utf8) { + charSequence597 = (decoder).readString(((Utf8) oldString597)); + } else { + charSequence597 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(597, charSequence597); + } else { + throw new RuntimeException(("Illegal union index for 'F597': "+ unionIndex597)); + } + } + int unionIndex598 = (decoder.readIndex()); + if (unionIndex598 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(598, null); + } else { + if (unionIndex598 == 1) { + Utf8 charSequence598; + Object oldString598 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(598); + if (oldString598 instanceof Utf8) { + charSequence598 = (decoder).readString(((Utf8) oldString598)); + } else { + charSequence598 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(598, charSequence598); + } else { + throw new RuntimeException(("Illegal union index for 'F598': "+ unionIndex598)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex599 = (decoder.readIndex()); + if (unionIndex599 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(599, null); + } else { + if (unionIndex599 == 1) { + Utf8 charSequence599; + Object oldString599 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(599); + if (oldString599 instanceof Utf8) { + charSequence599 = (decoder).readString(((Utf8) oldString599)); + } else { + charSequence599 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(599, charSequence599); + } else { + throw new RuntimeException(("Illegal union index for 'F599': "+ unionIndex599)); + } + } + int unionIndex600 = (decoder.readIndex()); + if (unionIndex600 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(600, null); + } else { + if (unionIndex600 == 1) { + Utf8 charSequence600; + Object oldString600 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(600); + if (oldString600 instanceof Utf8) { + charSequence600 = (decoder).readString(((Utf8) oldString600)); + } else { + charSequence600 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(600, charSequence600); + } else { + throw new RuntimeException(("Illegal union index for 'F600': "+ unionIndex600)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex601 = (decoder.readIndex()); + if (unionIndex601 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(601, null); + } else { + if (unionIndex601 == 1) { + Utf8 charSequence601; + Object oldString601 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(601); + if (oldString601 instanceof Utf8) { + charSequence601 = (decoder).readString(((Utf8) oldString601)); + } else { + charSequence601 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(601, charSequence601); + } else { + throw new RuntimeException(("Illegal union index for 'F601': "+ unionIndex601)); + } + } + int unionIndex602 = (decoder.readIndex()); + if (unionIndex602 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(602, null); + } else { + if (unionIndex602 == 1) { + Utf8 charSequence602; + Object oldString602 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(602); + if (oldString602 instanceof Utf8) { + charSequence602 = (decoder).readString(((Utf8) oldString602)); + } else { + charSequence602 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(602, charSequence602); + } else { + throw new RuntimeException(("Illegal union index for 'F602': "+ unionIndex602)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex603 = (decoder.readIndex()); + if (unionIndex603 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(603, null); + } else { + if (unionIndex603 == 1) { + Utf8 charSequence603; + Object oldString603 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(603); + if (oldString603 instanceof Utf8) { + charSequence603 = (decoder).readString(((Utf8) oldString603)); + } else { + charSequence603 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(603, charSequence603); + } else { + throw new RuntimeException(("Illegal union index for 'F603': "+ unionIndex603)); + } + } + int unionIndex604 = (decoder.readIndex()); + if (unionIndex604 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(604, null); + } else { + if (unionIndex604 == 1) { + Utf8 charSequence604; + Object oldString604 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(604); + if (oldString604 instanceof Utf8) { + charSequence604 = (decoder).readString(((Utf8) oldString604)); + } else { + charSequence604 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(604, charSequence604); + } else { + throw new RuntimeException(("Illegal union index for 'F604': "+ unionIndex604)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex605 = (decoder.readIndex()); + if (unionIndex605 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(605, null); + } else { + if (unionIndex605 == 1) { + Utf8 charSequence605; + Object oldString605 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(605); + if (oldString605 instanceof Utf8) { + charSequence605 = (decoder).readString(((Utf8) oldString605)); + } else { + charSequence605 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(605, charSequence605); + } else { + throw new RuntimeException(("Illegal union index for 'F605': "+ unionIndex605)); + } + } + int unionIndex606 = (decoder.readIndex()); + if (unionIndex606 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(606, null); + } else { + if (unionIndex606 == 1) { + Utf8 charSequence606; + Object oldString606 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(606); + if (oldString606 instanceof Utf8) { + charSequence606 = (decoder).readString(((Utf8) oldString606)); + } else { + charSequence606 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(606, charSequence606); + } else { + throw new RuntimeException(("Illegal union index for 'F606': "+ unionIndex606)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex607 = (decoder.readIndex()); + if (unionIndex607 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(607, null); + } else { + if (unionIndex607 == 1) { + Utf8 charSequence607; + Object oldString607 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(607); + if (oldString607 instanceof Utf8) { + charSequence607 = (decoder).readString(((Utf8) oldString607)); + } else { + charSequence607 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(607, charSequence607); + } else { + throw new RuntimeException(("Illegal union index for 'F607': "+ unionIndex607)); + } + } + int unionIndex608 = (decoder.readIndex()); + if (unionIndex608 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(608, null); + } else { + if (unionIndex608 == 1) { + Utf8 charSequence608; + Object oldString608 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(608); + if (oldString608 instanceof Utf8) { + charSequence608 = (decoder).readString(((Utf8) oldString608)); + } else { + charSequence608 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(608, charSequence608); + } else { + throw new RuntimeException(("Illegal union index for 'F608': "+ unionIndex608)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex609 = (decoder.readIndex()); + if (unionIndex609 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(609, null); + } else { + if (unionIndex609 == 1) { + Utf8 charSequence609; + Object oldString609 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(609); + if (oldString609 instanceof Utf8) { + charSequence609 = (decoder).readString(((Utf8) oldString609)); + } else { + charSequence609 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(609, charSequence609); + } else { + throw new RuntimeException(("Illegal union index for 'F609': "+ unionIndex609)); + } + } + int unionIndex610 = (decoder.readIndex()); + if (unionIndex610 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(610, null); + } else { + if (unionIndex610 == 1) { + Utf8 charSequence610; + Object oldString610 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(610); + if (oldString610 instanceof Utf8) { + charSequence610 = (decoder).readString(((Utf8) oldString610)); + } else { + charSequence610 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(610, charSequence610); + } else { + throw new RuntimeException(("Illegal union index for 'F610': "+ unionIndex610)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex611 = (decoder.readIndex()); + if (unionIndex611 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(611, null); + } else { + if (unionIndex611 == 1) { + Utf8 charSequence611; + Object oldString611 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(611); + if (oldString611 instanceof Utf8) { + charSequence611 = (decoder).readString(((Utf8) oldString611)); + } else { + charSequence611 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(611, charSequence611); + } else { + throw new RuntimeException(("Illegal union index for 'F611': "+ unionIndex611)); + } + } + int unionIndex612 = (decoder.readIndex()); + if (unionIndex612 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(612, null); + } else { + if (unionIndex612 == 1) { + Utf8 charSequence612; + Object oldString612 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(612); + if (oldString612 instanceof Utf8) { + charSequence612 = (decoder).readString(((Utf8) oldString612)); + } else { + charSequence612 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(612, charSequence612); + } else { + throw new RuntimeException(("Illegal union index for 'F612': "+ unionIndex612)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex613 = (decoder.readIndex()); + if (unionIndex613 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(613, null); + } else { + if (unionIndex613 == 1) { + Utf8 charSequence613; + Object oldString613 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(613); + if (oldString613 instanceof Utf8) { + charSequence613 = (decoder).readString(((Utf8) oldString613)); + } else { + charSequence613 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(613, charSequence613); + } else { + throw new RuntimeException(("Illegal union index for 'F613': "+ unionIndex613)); + } + } + int unionIndex614 = (decoder.readIndex()); + if (unionIndex614 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(614, null); + } else { + if (unionIndex614 == 1) { + Utf8 charSequence614; + Object oldString614 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(614); + if (oldString614 instanceof Utf8) { + charSequence614 = (decoder).readString(((Utf8) oldString614)); + } else { + charSequence614 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(614, charSequence614); + } else { + throw new RuntimeException(("Illegal union index for 'F614': "+ unionIndex614)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex615 = (decoder.readIndex()); + if (unionIndex615 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(615, null); + } else { + if (unionIndex615 == 1) { + Utf8 charSequence615; + Object oldString615 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(615); + if (oldString615 instanceof Utf8) { + charSequence615 = (decoder).readString(((Utf8) oldString615)); + } else { + charSequence615 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(615, charSequence615); + } else { + throw new RuntimeException(("Illegal union index for 'F615': "+ unionIndex615)); + } + } + int unionIndex616 = (decoder.readIndex()); + if (unionIndex616 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(616, null); + } else { + if (unionIndex616 == 1) { + Utf8 charSequence616; + Object oldString616 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(616); + if (oldString616 instanceof Utf8) { + charSequence616 = (decoder).readString(((Utf8) oldString616)); + } else { + charSequence616 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(616, charSequence616); + } else { + throw new RuntimeException(("Illegal union index for 'F616': "+ unionIndex616)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex617 = (decoder.readIndex()); + if (unionIndex617 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(617, null); + } else { + if (unionIndex617 == 1) { + Utf8 charSequence617; + Object oldString617 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(617); + if (oldString617 instanceof Utf8) { + charSequence617 = (decoder).readString(((Utf8) oldString617)); + } else { + charSequence617 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(617, charSequence617); + } else { + throw new RuntimeException(("Illegal union index for 'F617': "+ unionIndex617)); + } + } + int unionIndex618 = (decoder.readIndex()); + if (unionIndex618 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(618, null); + } else { + if (unionIndex618 == 1) { + Utf8 charSequence618; + Object oldString618 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(618); + if (oldString618 instanceof Utf8) { + charSequence618 = (decoder).readString(((Utf8) oldString618)); + } else { + charSequence618 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(618, charSequence618); + } else { + throw new RuntimeException(("Illegal union index for 'F618': "+ unionIndex618)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex619 = (decoder.readIndex()); + if (unionIndex619 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(619, null); + } else { + if (unionIndex619 == 1) { + Utf8 charSequence619; + Object oldString619 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(619); + if (oldString619 instanceof Utf8) { + charSequence619 = (decoder).readString(((Utf8) oldString619)); + } else { + charSequence619 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(619, charSequence619); + } else { + throw new RuntimeException(("Illegal union index for 'F619': "+ unionIndex619)); + } + } + int unionIndex620 = (decoder.readIndex()); + if (unionIndex620 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(620, null); + } else { + if (unionIndex620 == 1) { + Utf8 charSequence620; + Object oldString620 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(620); + if (oldString620 instanceof Utf8) { + charSequence620 = (decoder).readString(((Utf8) oldString620)); + } else { + charSequence620 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(620, charSequence620); + } else { + throw new RuntimeException(("Illegal union index for 'F620': "+ unionIndex620)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex621 = (decoder.readIndex()); + if (unionIndex621 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(621, null); + } else { + if (unionIndex621 == 1) { + Utf8 charSequence621; + Object oldString621 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(621); + if (oldString621 instanceof Utf8) { + charSequence621 = (decoder).readString(((Utf8) oldString621)); + } else { + charSequence621 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(621, charSequence621); + } else { + throw new RuntimeException(("Illegal union index for 'F621': "+ unionIndex621)); + } + } + int unionIndex622 = (decoder.readIndex()); + if (unionIndex622 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(622, null); + } else { + if (unionIndex622 == 1) { + Utf8 charSequence622; + Object oldString622 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(622); + if (oldString622 instanceof Utf8) { + charSequence622 = (decoder).readString(((Utf8) oldString622)); + } else { + charSequence622 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(622, charSequence622); + } else { + throw new RuntimeException(("Illegal union index for 'F622': "+ unionIndex622)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex623 = (decoder.readIndex()); + if (unionIndex623 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(623, null); + } else { + if (unionIndex623 == 1) { + Utf8 charSequence623; + Object oldString623 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(623); + if (oldString623 instanceof Utf8) { + charSequence623 = (decoder).readString(((Utf8) oldString623)); + } else { + charSequence623 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(623, charSequence623); + } else { + throw new RuntimeException(("Illegal union index for 'F623': "+ unionIndex623)); + } + } + int unionIndex624 = (decoder.readIndex()); + if (unionIndex624 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(624, null); + } else { + if (unionIndex624 == 1) { + Utf8 charSequence624; + Object oldString624 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(624); + if (oldString624 instanceof Utf8) { + charSequence624 = (decoder).readString(((Utf8) oldString624)); + } else { + charSequence624 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(624, charSequence624); + } else { + throw new RuntimeException(("Illegal union index for 'F624': "+ unionIndex624)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex625 = (decoder.readIndex()); + if (unionIndex625 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(625, null); + } else { + if (unionIndex625 == 1) { + Utf8 charSequence625; + Object oldString625 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(625); + if (oldString625 instanceof Utf8) { + charSequence625 = (decoder).readString(((Utf8) oldString625)); + } else { + charSequence625 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(625, charSequence625); + } else { + throw new RuntimeException(("Illegal union index for 'F625': "+ unionIndex625)); + } + } + int unionIndex626 = (decoder.readIndex()); + if (unionIndex626 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(626, null); + } else { + if (unionIndex626 == 1) { + Utf8 charSequence626; + Object oldString626 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(626); + if (oldString626 instanceof Utf8) { + charSequence626 = (decoder).readString(((Utf8) oldString626)); + } else { + charSequence626 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(626, charSequence626); + } else { + throw new RuntimeException(("Illegal union index for 'F626': "+ unionIndex626)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex627 = (decoder.readIndex()); + if (unionIndex627 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(627, null); + } else { + if (unionIndex627 == 1) { + Utf8 charSequence627; + Object oldString627 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(627); + if (oldString627 instanceof Utf8) { + charSequence627 = (decoder).readString(((Utf8) oldString627)); + } else { + charSequence627 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(627, charSequence627); + } else { + throw new RuntimeException(("Illegal union index for 'F627': "+ unionIndex627)); + } + } + int unionIndex628 = (decoder.readIndex()); + if (unionIndex628 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(628, null); + } else { + if (unionIndex628 == 1) { + Utf8 charSequence628; + Object oldString628 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(628); + if (oldString628 instanceof Utf8) { + charSequence628 = (decoder).readString(((Utf8) oldString628)); + } else { + charSequence628 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(628, charSequence628); + } else { + throw new RuntimeException(("Illegal union index for 'F628': "+ unionIndex628)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex629 = (decoder.readIndex()); + if (unionIndex629 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(629, null); + } else { + if (unionIndex629 == 1) { + Utf8 charSequence629; + Object oldString629 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(629); + if (oldString629 instanceof Utf8) { + charSequence629 = (decoder).readString(((Utf8) oldString629)); + } else { + charSequence629 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(629, charSequence629); + } else { + throw new RuntimeException(("Illegal union index for 'F629': "+ unionIndex629)); + } + } + int unionIndex630 = (decoder.readIndex()); + if (unionIndex630 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(630, null); + } else { + if (unionIndex630 == 1) { + Utf8 charSequence630; + Object oldString630 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(630); + if (oldString630 instanceof Utf8) { + charSequence630 = (decoder).readString(((Utf8) oldString630)); + } else { + charSequence630 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(630, charSequence630); + } else { + throw new RuntimeException(("Illegal union index for 'F630': "+ unionIndex630)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex631 = (decoder.readIndex()); + if (unionIndex631 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(631, null); + } else { + if (unionIndex631 == 1) { + Utf8 charSequence631; + Object oldString631 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(631); + if (oldString631 instanceof Utf8) { + charSequence631 = (decoder).readString(((Utf8) oldString631)); + } else { + charSequence631 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(631, charSequence631); + } else { + throw new RuntimeException(("Illegal union index for 'F631': "+ unionIndex631)); + } + } + int unionIndex632 = (decoder.readIndex()); + if (unionIndex632 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(632, null); + } else { + if (unionIndex632 == 1) { + Utf8 charSequence632; + Object oldString632 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(632); + if (oldString632 instanceof Utf8) { + charSequence632 = (decoder).readString(((Utf8) oldString632)); + } else { + charSequence632 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(632, charSequence632); + } else { + throw new RuntimeException(("Illegal union index for 'F632': "+ unionIndex632)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex633 = (decoder.readIndex()); + if (unionIndex633 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(633, null); + } else { + if (unionIndex633 == 1) { + Utf8 charSequence633; + Object oldString633 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(633); + if (oldString633 instanceof Utf8) { + charSequence633 = (decoder).readString(((Utf8) oldString633)); + } else { + charSequence633 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(633, charSequence633); + } else { + throw new RuntimeException(("Illegal union index for 'F633': "+ unionIndex633)); + } + } + int unionIndex634 = (decoder.readIndex()); + if (unionIndex634 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(634, null); + } else { + if (unionIndex634 == 1) { + Utf8 charSequence634; + Object oldString634 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(634); + if (oldString634 instanceof Utf8) { + charSequence634 = (decoder).readString(((Utf8) oldString634)); + } else { + charSequence634 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(634, charSequence634); + } else { + throw new RuntimeException(("Illegal union index for 'F634': "+ unionIndex634)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex635 = (decoder.readIndex()); + if (unionIndex635 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(635, null); + } else { + if (unionIndex635 == 1) { + Utf8 charSequence635; + Object oldString635 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(635); + if (oldString635 instanceof Utf8) { + charSequence635 = (decoder).readString(((Utf8) oldString635)); + } else { + charSequence635 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(635, charSequence635); + } else { + throw new RuntimeException(("Illegal union index for 'F635': "+ unionIndex635)); + } + } + int unionIndex636 = (decoder.readIndex()); + if (unionIndex636 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(636, null); + } else { + if (unionIndex636 == 1) { + Utf8 charSequence636; + Object oldString636 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(636); + if (oldString636 instanceof Utf8) { + charSequence636 = (decoder).readString(((Utf8) oldString636)); + } else { + charSequence636 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(636, charSequence636); + } else { + throw new RuntimeException(("Illegal union index for 'F636': "+ unionIndex636)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex637 = (decoder.readIndex()); + if (unionIndex637 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(637, null); + } else { + if (unionIndex637 == 1) { + Utf8 charSequence637; + Object oldString637 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(637); + if (oldString637 instanceof Utf8) { + charSequence637 = (decoder).readString(((Utf8) oldString637)); + } else { + charSequence637 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(637, charSequence637); + } else { + throw new RuntimeException(("Illegal union index for 'F637': "+ unionIndex637)); + } + } + int unionIndex638 = (decoder.readIndex()); + if (unionIndex638 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(638, null); + } else { + if (unionIndex638 == 1) { + Utf8 charSequence638; + Object oldString638 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(638); + if (oldString638 instanceof Utf8) { + charSequence638 = (decoder).readString(((Utf8) oldString638)); + } else { + charSequence638 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(638, charSequence638); + } else { + throw new RuntimeException(("Illegal union index for 'F638': "+ unionIndex638)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex639 = (decoder.readIndex()); + if (unionIndex639 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(639, null); + } else { + if (unionIndex639 == 1) { + Utf8 charSequence639; + Object oldString639 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(639); + if (oldString639 instanceof Utf8) { + charSequence639 = (decoder).readString(((Utf8) oldString639)); + } else { + charSequence639 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(639, charSequence639); + } else { + throw new RuntimeException(("Illegal union index for 'F639': "+ unionIndex639)); + } + } + int unionIndex640 = (decoder.readIndex()); + if (unionIndex640 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(640, null); + } else { + if (unionIndex640 == 1) { + Utf8 charSequence640; + Object oldString640 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(640); + if (oldString640 instanceof Utf8) { + charSequence640 = (decoder).readString(((Utf8) oldString640)); + } else { + charSequence640 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(640, charSequence640); + } else { + throw new RuntimeException(("Illegal union index for 'F640': "+ unionIndex640)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex641 = (decoder.readIndex()); + if (unionIndex641 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(641, null); + } else { + if (unionIndex641 == 1) { + Utf8 charSequence641; + Object oldString641 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(641); + if (oldString641 instanceof Utf8) { + charSequence641 = (decoder).readString(((Utf8) oldString641)); + } else { + charSequence641 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(641, charSequence641); + } else { + throw new RuntimeException(("Illegal union index for 'F641': "+ unionIndex641)); + } + } + int unionIndex642 = (decoder.readIndex()); + if (unionIndex642 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(642, null); + } else { + if (unionIndex642 == 1) { + Utf8 charSequence642; + Object oldString642 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(642); + if (oldString642 instanceof Utf8) { + charSequence642 = (decoder).readString(((Utf8) oldString642)); + } else { + charSequence642 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(642, charSequence642); + } else { + throw new RuntimeException(("Illegal union index for 'F642': "+ unionIndex642)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex643 = (decoder.readIndex()); + if (unionIndex643 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(643, null); + } else { + if (unionIndex643 == 1) { + Utf8 charSequence643; + Object oldString643 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(643); + if (oldString643 instanceof Utf8) { + charSequence643 = (decoder).readString(((Utf8) oldString643)); + } else { + charSequence643 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(643, charSequence643); + } else { + throw new RuntimeException(("Illegal union index for 'F643': "+ unionIndex643)); + } + } + int unionIndex644 = (decoder.readIndex()); + if (unionIndex644 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(644, null); + } else { + if (unionIndex644 == 1) { + Utf8 charSequence644; + Object oldString644 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(644); + if (oldString644 instanceof Utf8) { + charSequence644 = (decoder).readString(((Utf8) oldString644)); + } else { + charSequence644 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(644, charSequence644); + } else { + throw new RuntimeException(("Illegal union index for 'F644': "+ unionIndex644)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex645 = (decoder.readIndex()); + if (unionIndex645 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(645, null); + } else { + if (unionIndex645 == 1) { + Utf8 charSequence645; + Object oldString645 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(645); + if (oldString645 instanceof Utf8) { + charSequence645 = (decoder).readString(((Utf8) oldString645)); + } else { + charSequence645 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(645, charSequence645); + } else { + throw new RuntimeException(("Illegal union index for 'F645': "+ unionIndex645)); + } + } + int unionIndex646 = (decoder.readIndex()); + if (unionIndex646 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(646, null); + } else { + if (unionIndex646 == 1) { + Utf8 charSequence646; + Object oldString646 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(646); + if (oldString646 instanceof Utf8) { + charSequence646 = (decoder).readString(((Utf8) oldString646)); + } else { + charSequence646 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(646, charSequence646); + } else { + throw new RuntimeException(("Illegal union index for 'F646': "+ unionIndex646)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex647 = (decoder.readIndex()); + if (unionIndex647 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(647, null); + } else { + if (unionIndex647 == 1) { + Utf8 charSequence647; + Object oldString647 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(647); + if (oldString647 instanceof Utf8) { + charSequence647 = (decoder).readString(((Utf8) oldString647)); + } else { + charSequence647 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(647, charSequence647); + } else { + throw new RuntimeException(("Illegal union index for 'F647': "+ unionIndex647)); + } + } + int unionIndex648 = (decoder.readIndex()); + if (unionIndex648 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(648, null); + } else { + if (unionIndex648 == 1) { + Utf8 charSequence648; + Object oldString648 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(648); + if (oldString648 instanceof Utf8) { + charSequence648 = (decoder).readString(((Utf8) oldString648)); + } else { + charSequence648 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(648, charSequence648); + } else { + throw new RuntimeException(("Illegal union index for 'F648': "+ unionIndex648)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex649 = (decoder.readIndex()); + if (unionIndex649 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(649, null); + } else { + if (unionIndex649 == 1) { + Utf8 charSequence649; + Object oldString649 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(649); + if (oldString649 instanceof Utf8) { + charSequence649 = (decoder).readString(((Utf8) oldString649)); + } else { + charSequence649 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(649, charSequence649); + } else { + throw new RuntimeException(("Illegal union index for 'F649': "+ unionIndex649)); + } + } + int unionIndex650 = (decoder.readIndex()); + if (unionIndex650 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(650, null); + } else { + if (unionIndex650 == 1) { + Utf8 charSequence650; + Object oldString650 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(650); + if (oldString650 instanceof Utf8) { + charSequence650 = (decoder).readString(((Utf8) oldString650)); + } else { + charSequence650 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(650, charSequence650); + } else { + throw new RuntimeException(("Illegal union index for 'F650': "+ unionIndex650)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex651 = (decoder.readIndex()); + if (unionIndex651 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(651, null); + } else { + if (unionIndex651 == 1) { + Utf8 charSequence651; + Object oldString651 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(651); + if (oldString651 instanceof Utf8) { + charSequence651 = (decoder).readString(((Utf8) oldString651)); + } else { + charSequence651 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(651, charSequence651); + } else { + throw new RuntimeException(("Illegal union index for 'F651': "+ unionIndex651)); + } + } + int unionIndex652 = (decoder.readIndex()); + if (unionIndex652 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(652, null); + } else { + if (unionIndex652 == 1) { + Utf8 charSequence652; + Object oldString652 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(652); + if (oldString652 instanceof Utf8) { + charSequence652 = (decoder).readString(((Utf8) oldString652)); + } else { + charSequence652 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(652, charSequence652); + } else { + throw new RuntimeException(("Illegal union index for 'F652': "+ unionIndex652)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex653 = (decoder.readIndex()); + if (unionIndex653 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(653, null); + } else { + if (unionIndex653 == 1) { + Utf8 charSequence653; + Object oldString653 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(653); + if (oldString653 instanceof Utf8) { + charSequence653 = (decoder).readString(((Utf8) oldString653)); + } else { + charSequence653 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(653, charSequence653); + } else { + throw new RuntimeException(("Illegal union index for 'F653': "+ unionIndex653)); + } + } + int unionIndex654 = (decoder.readIndex()); + if (unionIndex654 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(654, null); + } else { + if (unionIndex654 == 1) { + Utf8 charSequence654; + Object oldString654 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(654); + if (oldString654 instanceof Utf8) { + charSequence654 = (decoder).readString(((Utf8) oldString654)); + } else { + charSequence654 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(654, charSequence654); + } else { + throw new RuntimeException(("Illegal union index for 'F654': "+ unionIndex654)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex655 = (decoder.readIndex()); + if (unionIndex655 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(655, null); + } else { + if (unionIndex655 == 1) { + Utf8 charSequence655; + Object oldString655 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(655); + if (oldString655 instanceof Utf8) { + charSequence655 = (decoder).readString(((Utf8) oldString655)); + } else { + charSequence655 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(655, charSequence655); + } else { + throw new RuntimeException(("Illegal union index for 'F655': "+ unionIndex655)); + } + } + int unionIndex656 = (decoder.readIndex()); + if (unionIndex656 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(656, null); + } else { + if (unionIndex656 == 1) { + Utf8 charSequence656; + Object oldString656 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(656); + if (oldString656 instanceof Utf8) { + charSequence656 = (decoder).readString(((Utf8) oldString656)); + } else { + charSequence656 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(656, charSequence656); + } else { + throw new RuntimeException(("Illegal union index for 'F656': "+ unionIndex656)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex657 = (decoder.readIndex()); + if (unionIndex657 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(657, null); + } else { + if (unionIndex657 == 1) { + Utf8 charSequence657; + Object oldString657 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(657); + if (oldString657 instanceof Utf8) { + charSequence657 = (decoder).readString(((Utf8) oldString657)); + } else { + charSequence657 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(657, charSequence657); + } else { + throw new RuntimeException(("Illegal union index for 'F657': "+ unionIndex657)); + } + } + int unionIndex658 = (decoder.readIndex()); + if (unionIndex658 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(658, null); + } else { + if (unionIndex658 == 1) { + Utf8 charSequence658; + Object oldString658 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(658); + if (oldString658 instanceof Utf8) { + charSequence658 = (decoder).readString(((Utf8) oldString658)); + } else { + charSequence658 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(658, charSequence658); + } else { + throw new RuntimeException(("Illegal union index for 'F658': "+ unionIndex658)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex659 = (decoder.readIndex()); + if (unionIndex659 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(659, null); + } else { + if (unionIndex659 == 1) { + Utf8 charSequence659; + Object oldString659 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(659); + if (oldString659 instanceof Utf8) { + charSequence659 = (decoder).readString(((Utf8) oldString659)); + } else { + charSequence659 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(659, charSequence659); + } else { + throw new RuntimeException(("Illegal union index for 'F659': "+ unionIndex659)); + } + } + int unionIndex660 = (decoder.readIndex()); + if (unionIndex660 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(660, null); + } else { + if (unionIndex660 == 1) { + Utf8 charSequence660; + Object oldString660 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(660); + if (oldString660 instanceof Utf8) { + charSequence660 = (decoder).readString(((Utf8) oldString660)); + } else { + charSequence660 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(660, charSequence660); + } else { + throw new RuntimeException(("Illegal union index for 'F660': "+ unionIndex660)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex661 = (decoder.readIndex()); + if (unionIndex661 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(661, null); + } else { + if (unionIndex661 == 1) { + Utf8 charSequence661; + Object oldString661 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(661); + if (oldString661 instanceof Utf8) { + charSequence661 = (decoder).readString(((Utf8) oldString661)); + } else { + charSequence661 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(661, charSequence661); + } else { + throw new RuntimeException(("Illegal union index for 'F661': "+ unionIndex661)); + } + } + int unionIndex662 = (decoder.readIndex()); + if (unionIndex662 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(662, null); + } else { + if (unionIndex662 == 1) { + Utf8 charSequence662; + Object oldString662 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(662); + if (oldString662 instanceof Utf8) { + charSequence662 = (decoder).readString(((Utf8) oldString662)); + } else { + charSequence662 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(662, charSequence662); + } else { + throw new RuntimeException(("Illegal union index for 'F662': "+ unionIndex662)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex663 = (decoder.readIndex()); + if (unionIndex663 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(663, null); + } else { + if (unionIndex663 == 1) { + Utf8 charSequence663; + Object oldString663 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(663); + if (oldString663 instanceof Utf8) { + charSequence663 = (decoder).readString(((Utf8) oldString663)); + } else { + charSequence663 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(663, charSequence663); + } else { + throw new RuntimeException(("Illegal union index for 'F663': "+ unionIndex663)); + } + } + int unionIndex664 = (decoder.readIndex()); + if (unionIndex664 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(664, null); + } else { + if (unionIndex664 == 1) { + Utf8 charSequence664; + Object oldString664 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(664); + if (oldString664 instanceof Utf8) { + charSequence664 = (decoder).readString(((Utf8) oldString664)); + } else { + charSequence664 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(664, charSequence664); + } else { + throw new RuntimeException(("Illegal union index for 'F664': "+ unionIndex664)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex665 = (decoder.readIndex()); + if (unionIndex665 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(665, null); + } else { + if (unionIndex665 == 1) { + Utf8 charSequence665; + Object oldString665 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(665); + if (oldString665 instanceof Utf8) { + charSequence665 = (decoder).readString(((Utf8) oldString665)); + } else { + charSequence665 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(665, charSequence665); + } else { + throw new RuntimeException(("Illegal union index for 'F665': "+ unionIndex665)); + } + } + int unionIndex666 = (decoder.readIndex()); + if (unionIndex666 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(666, null); + } else { + if (unionIndex666 == 1) { + Utf8 charSequence666; + Object oldString666 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(666); + if (oldString666 instanceof Utf8) { + charSequence666 = (decoder).readString(((Utf8) oldString666)); + } else { + charSequence666 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(666, charSequence666); + } else { + throw new RuntimeException(("Illegal union index for 'F666': "+ unionIndex666)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex667 = (decoder.readIndex()); + if (unionIndex667 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(667, null); + } else { + if (unionIndex667 == 1) { + Utf8 charSequence667; + Object oldString667 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(667); + if (oldString667 instanceof Utf8) { + charSequence667 = (decoder).readString(((Utf8) oldString667)); + } else { + charSequence667 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(667, charSequence667); + } else { + throw new RuntimeException(("Illegal union index for 'F667': "+ unionIndex667)); + } + } + int unionIndex668 = (decoder.readIndex()); + if (unionIndex668 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(668, null); + } else { + if (unionIndex668 == 1) { + Utf8 charSequence668; + Object oldString668 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(668); + if (oldString668 instanceof Utf8) { + charSequence668 = (decoder).readString(((Utf8) oldString668)); + } else { + charSequence668 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(668, charSequence668); + } else { + throw new RuntimeException(("Illegal union index for 'F668': "+ unionIndex668)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex669 = (decoder.readIndex()); + if (unionIndex669 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(669, null); + } else { + if (unionIndex669 == 1) { + Utf8 charSequence669; + Object oldString669 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(669); + if (oldString669 instanceof Utf8) { + charSequence669 = (decoder).readString(((Utf8) oldString669)); + } else { + charSequence669 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(669, charSequence669); + } else { + throw new RuntimeException(("Illegal union index for 'F669': "+ unionIndex669)); + } + } + int unionIndex670 = (decoder.readIndex()); + if (unionIndex670 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(670, null); + } else { + if (unionIndex670 == 1) { + Utf8 charSequence670; + Object oldString670 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(670); + if (oldString670 instanceof Utf8) { + charSequence670 = (decoder).readString(((Utf8) oldString670)); + } else { + charSequence670 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(670, charSequence670); + } else { + throw new RuntimeException(("Illegal union index for 'F670': "+ unionIndex670)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex671 = (decoder.readIndex()); + if (unionIndex671 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(671, null); + } else { + if (unionIndex671 == 1) { + Utf8 charSequence671; + Object oldString671 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(671); + if (oldString671 instanceof Utf8) { + charSequence671 = (decoder).readString(((Utf8) oldString671)); + } else { + charSequence671 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(671, charSequence671); + } else { + throw new RuntimeException(("Illegal union index for 'F671': "+ unionIndex671)); + } + } + int unionIndex672 = (decoder.readIndex()); + if (unionIndex672 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(672, null); + } else { + if (unionIndex672 == 1) { + Utf8 charSequence672; + Object oldString672 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(672); + if (oldString672 instanceof Utf8) { + charSequence672 = (decoder).readString(((Utf8) oldString672)); + } else { + charSequence672 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(672, charSequence672); + } else { + throw new RuntimeException(("Illegal union index for 'F672': "+ unionIndex672)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex673 = (decoder.readIndex()); + if (unionIndex673 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(673, null); + } else { + if (unionIndex673 == 1) { + Utf8 charSequence673; + Object oldString673 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(673); + if (oldString673 instanceof Utf8) { + charSequence673 = (decoder).readString(((Utf8) oldString673)); + } else { + charSequence673 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(673, charSequence673); + } else { + throw new RuntimeException(("Illegal union index for 'F673': "+ unionIndex673)); + } + } + int unionIndex674 = (decoder.readIndex()); + if (unionIndex674 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(674, null); + } else { + if (unionIndex674 == 1) { + Utf8 charSequence674; + Object oldString674 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(674); + if (oldString674 instanceof Utf8) { + charSequence674 = (decoder).readString(((Utf8) oldString674)); + } else { + charSequence674 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(674, charSequence674); + } else { + throw new RuntimeException(("Illegal union index for 'F674': "+ unionIndex674)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex675 = (decoder.readIndex()); + if (unionIndex675 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(675, null); + } else { + if (unionIndex675 == 1) { + Utf8 charSequence675; + Object oldString675 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(675); + if (oldString675 instanceof Utf8) { + charSequence675 = (decoder).readString(((Utf8) oldString675)); + } else { + charSequence675 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(675, charSequence675); + } else { + throw new RuntimeException(("Illegal union index for 'F675': "+ unionIndex675)); + } + } + int unionIndex676 = (decoder.readIndex()); + if (unionIndex676 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(676, null); + } else { + if (unionIndex676 == 1) { + Utf8 charSequence676; + Object oldString676 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(676); + if (oldString676 instanceof Utf8) { + charSequence676 = (decoder).readString(((Utf8) oldString676)); + } else { + charSequence676 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(676, charSequence676); + } else { + throw new RuntimeException(("Illegal union index for 'F676': "+ unionIndex676)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex677 = (decoder.readIndex()); + if (unionIndex677 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(677, null); + } else { + if (unionIndex677 == 1) { + Utf8 charSequence677; + Object oldString677 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(677); + if (oldString677 instanceof Utf8) { + charSequence677 = (decoder).readString(((Utf8) oldString677)); + } else { + charSequence677 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(677, charSequence677); + } else { + throw new RuntimeException(("Illegal union index for 'F677': "+ unionIndex677)); + } + } + int unionIndex678 = (decoder.readIndex()); + if (unionIndex678 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(678, null); + } else { + if (unionIndex678 == 1) { + Utf8 charSequence678; + Object oldString678 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(678); + if (oldString678 instanceof Utf8) { + charSequence678 = (decoder).readString(((Utf8) oldString678)); + } else { + charSequence678 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(678, charSequence678); + } else { + throw new RuntimeException(("Illegal union index for 'F678': "+ unionIndex678)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex679 = (decoder.readIndex()); + if (unionIndex679 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(679, null); + } else { + if (unionIndex679 == 1) { + Utf8 charSequence679; + Object oldString679 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(679); + if (oldString679 instanceof Utf8) { + charSequence679 = (decoder).readString(((Utf8) oldString679)); + } else { + charSequence679 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(679, charSequence679); + } else { + throw new RuntimeException(("Illegal union index for 'F679': "+ unionIndex679)); + } + } + int unionIndex680 = (decoder.readIndex()); + if (unionIndex680 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(680, null); + } else { + if (unionIndex680 == 1) { + Utf8 charSequence680; + Object oldString680 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(680); + if (oldString680 instanceof Utf8) { + charSequence680 = (decoder).readString(((Utf8) oldString680)); + } else { + charSequence680 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(680, charSequence680); + } else { + throw new RuntimeException(("Illegal union index for 'F680': "+ unionIndex680)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex681 = (decoder.readIndex()); + if (unionIndex681 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(681, null); + } else { + if (unionIndex681 == 1) { + Utf8 charSequence681; + Object oldString681 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(681); + if (oldString681 instanceof Utf8) { + charSequence681 = (decoder).readString(((Utf8) oldString681)); + } else { + charSequence681 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(681, charSequence681); + } else { + throw new RuntimeException(("Illegal union index for 'F681': "+ unionIndex681)); + } + } + int unionIndex682 = (decoder.readIndex()); + if (unionIndex682 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(682, null); + } else { + if (unionIndex682 == 1) { + Utf8 charSequence682; + Object oldString682 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(682); + if (oldString682 instanceof Utf8) { + charSequence682 = (decoder).readString(((Utf8) oldString682)); + } else { + charSequence682 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(682, charSequence682); + } else { + throw new RuntimeException(("Illegal union index for 'F682': "+ unionIndex682)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex683 = (decoder.readIndex()); + if (unionIndex683 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(683, null); + } else { + if (unionIndex683 == 1) { + Utf8 charSequence683; + Object oldString683 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(683); + if (oldString683 instanceof Utf8) { + charSequence683 = (decoder).readString(((Utf8) oldString683)); + } else { + charSequence683 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(683, charSequence683); + } else { + throw new RuntimeException(("Illegal union index for 'F683': "+ unionIndex683)); + } + } + int unionIndex684 = (decoder.readIndex()); + if (unionIndex684 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(684, null); + } else { + if (unionIndex684 == 1) { + Utf8 charSequence684; + Object oldString684 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(684); + if (oldString684 instanceof Utf8) { + charSequence684 = (decoder).readString(((Utf8) oldString684)); + } else { + charSequence684 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(684, charSequence684); + } else { + throw new RuntimeException(("Illegal union index for 'F684': "+ unionIndex684)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex685 = (decoder.readIndex()); + if (unionIndex685 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(685, null); + } else { + if (unionIndex685 == 1) { + Utf8 charSequence685; + Object oldString685 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(685); + if (oldString685 instanceof Utf8) { + charSequence685 = (decoder).readString(((Utf8) oldString685)); + } else { + charSequence685 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(685, charSequence685); + } else { + throw new RuntimeException(("Illegal union index for 'F685': "+ unionIndex685)); + } + } + int unionIndex686 = (decoder.readIndex()); + if (unionIndex686 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(686, null); + } else { + if (unionIndex686 == 1) { + Utf8 charSequence686; + Object oldString686 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(686); + if (oldString686 instanceof Utf8) { + charSequence686 = (decoder).readString(((Utf8) oldString686)); + } else { + charSequence686 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(686, charSequence686); + } else { + throw new RuntimeException(("Illegal union index for 'F686': "+ unionIndex686)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex687 = (decoder.readIndex()); + if (unionIndex687 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(687, null); + } else { + if (unionIndex687 == 1) { + Utf8 charSequence687; + Object oldString687 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(687); + if (oldString687 instanceof Utf8) { + charSequence687 = (decoder).readString(((Utf8) oldString687)); + } else { + charSequence687 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(687, charSequence687); + } else { + throw new RuntimeException(("Illegal union index for 'F687': "+ unionIndex687)); + } + } + int unionIndex688 = (decoder.readIndex()); + if (unionIndex688 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(688, null); + } else { + if (unionIndex688 == 1) { + Utf8 charSequence688; + Object oldString688 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(688); + if (oldString688 instanceof Utf8) { + charSequence688 = (decoder).readString(((Utf8) oldString688)); + } else { + charSequence688 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(688, charSequence688); + } else { + throw new RuntimeException(("Illegal union index for 'F688': "+ unionIndex688)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex689 = (decoder.readIndex()); + if (unionIndex689 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(689, null); + } else { + if (unionIndex689 == 1) { + Utf8 charSequence689; + Object oldString689 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(689); + if (oldString689 instanceof Utf8) { + charSequence689 = (decoder).readString(((Utf8) oldString689)); + } else { + charSequence689 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(689, charSequence689); + } else { + throw new RuntimeException(("Illegal union index for 'F689': "+ unionIndex689)); + } + } + int unionIndex690 = (decoder.readIndex()); + if (unionIndex690 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(690, null); + } else { + if (unionIndex690 == 1) { + Utf8 charSequence690; + Object oldString690 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(690); + if (oldString690 instanceof Utf8) { + charSequence690 = (decoder).readString(((Utf8) oldString690)); + } else { + charSequence690 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(690, charSequence690); + } else { + throw new RuntimeException(("Illegal union index for 'F690': "+ unionIndex690)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex691 = (decoder.readIndex()); + if (unionIndex691 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(691, null); + } else { + if (unionIndex691 == 1) { + Utf8 charSequence691; + Object oldString691 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(691); + if (oldString691 instanceof Utf8) { + charSequence691 = (decoder).readString(((Utf8) oldString691)); + } else { + charSequence691 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(691, charSequence691); + } else { + throw new RuntimeException(("Illegal union index for 'F691': "+ unionIndex691)); + } + } + int unionIndex692 = (decoder.readIndex()); + if (unionIndex692 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(692, null); + } else { + if (unionIndex692 == 1) { + Utf8 charSequence692; + Object oldString692 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(692); + if (oldString692 instanceof Utf8) { + charSequence692 = (decoder).readString(((Utf8) oldString692)); + } else { + charSequence692 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(692, charSequence692); + } else { + throw new RuntimeException(("Illegal union index for 'F692': "+ unionIndex692)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex693 = (decoder.readIndex()); + if (unionIndex693 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(693, null); + } else { + if (unionIndex693 == 1) { + Utf8 charSequence693; + Object oldString693 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(693); + if (oldString693 instanceof Utf8) { + charSequence693 = (decoder).readString(((Utf8) oldString693)); + } else { + charSequence693 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(693, charSequence693); + } else { + throw new RuntimeException(("Illegal union index for 'F693': "+ unionIndex693)); + } + } + int unionIndex694 = (decoder.readIndex()); + if (unionIndex694 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(694, null); + } else { + if (unionIndex694 == 1) { + Utf8 charSequence694; + Object oldString694 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(694); + if (oldString694 instanceof Utf8) { + charSequence694 = (decoder).readString(((Utf8) oldString694)); + } else { + charSequence694 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(694, charSequence694); + } else { + throw new RuntimeException(("Illegal union index for 'F694': "+ unionIndex694)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex695 = (decoder.readIndex()); + if (unionIndex695 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(695, null); + } else { + if (unionIndex695 == 1) { + Utf8 charSequence695; + Object oldString695 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(695); + if (oldString695 instanceof Utf8) { + charSequence695 = (decoder).readString(((Utf8) oldString695)); + } else { + charSequence695 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(695, charSequence695); + } else { + throw new RuntimeException(("Illegal union index for 'F695': "+ unionIndex695)); + } + } + int unionIndex696 = (decoder.readIndex()); + if (unionIndex696 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(696, null); + } else { + if (unionIndex696 == 1) { + Utf8 charSequence696; + Object oldString696 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(696); + if (oldString696 instanceof Utf8) { + charSequence696 = (decoder).readString(((Utf8) oldString696)); + } else { + charSequence696 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(696, charSequence696); + } else { + throw new RuntimeException(("Illegal union index for 'F696': "+ unionIndex696)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex697 = (decoder.readIndex()); + if (unionIndex697 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(697, null); + } else { + if (unionIndex697 == 1) { + Utf8 charSequence697; + Object oldString697 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(697); + if (oldString697 instanceof Utf8) { + charSequence697 = (decoder).readString(((Utf8) oldString697)); + } else { + charSequence697 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(697, charSequence697); + } else { + throw new RuntimeException(("Illegal union index for 'F697': "+ unionIndex697)); + } + } + int unionIndex698 = (decoder.readIndex()); + if (unionIndex698 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(698, null); + } else { + if (unionIndex698 == 1) { + Utf8 charSequence698; + Object oldString698 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(698); + if (oldString698 instanceof Utf8) { + charSequence698 = (decoder).readString(((Utf8) oldString698)); + } else { + charSequence698 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(698, charSequence698); + } else { + throw new RuntimeException(("Illegal union index for 'F698': "+ unionIndex698)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex699 = (decoder.readIndex()); + if (unionIndex699 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(699, null); + } else { + if (unionIndex699 == 1) { + Utf8 charSequence699; + Object oldString699 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(699); + if (oldString699 instanceof Utf8) { + charSequence699 = (decoder).readString(((Utf8) oldString699)); + } else { + charSequence699 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(699, charSequence699); + } else { + throw new RuntimeException(("Illegal union index for 'F699': "+ unionIndex699)); + } + } + int unionIndex700 = (decoder.readIndex()); + if (unionIndex700 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(700, null); + } else { + if (unionIndex700 == 1) { + Utf8 charSequence700; + Object oldString700 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(700); + if (oldString700 instanceof Utf8) { + charSequence700 = (decoder).readString(((Utf8) oldString700)); + } else { + charSequence700 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(700, charSequence700); + } else { + throw new RuntimeException(("Illegal union index for 'F700': "+ unionIndex700)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex701 = (decoder.readIndex()); + if (unionIndex701 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(701, null); + } else { + if (unionIndex701 == 1) { + Utf8 charSequence701; + Object oldString701 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(701); + if (oldString701 instanceof Utf8) { + charSequence701 = (decoder).readString(((Utf8) oldString701)); + } else { + charSequence701 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(701, charSequence701); + } else { + throw new RuntimeException(("Illegal union index for 'F701': "+ unionIndex701)); + } + } + int unionIndex702 = (decoder.readIndex()); + if (unionIndex702 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(702, null); + } else { + if (unionIndex702 == 1) { + Utf8 charSequence702; + Object oldString702 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(702); + if (oldString702 instanceof Utf8) { + charSequence702 = (decoder).readString(((Utf8) oldString702)); + } else { + charSequence702 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(702, charSequence702); + } else { + throw new RuntimeException(("Illegal union index for 'F702': "+ unionIndex702)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex703 = (decoder.readIndex()); + if (unionIndex703 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(703, null); + } else { + if (unionIndex703 == 1) { + Utf8 charSequence703; + Object oldString703 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(703); + if (oldString703 instanceof Utf8) { + charSequence703 = (decoder).readString(((Utf8) oldString703)); + } else { + charSequence703 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(703, charSequence703); + } else { + throw new RuntimeException(("Illegal union index for 'F703': "+ unionIndex703)); + } + } + int unionIndex704 = (decoder.readIndex()); + if (unionIndex704 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(704, null); + } else { + if (unionIndex704 == 1) { + Utf8 charSequence704; + Object oldString704 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(704); + if (oldString704 instanceof Utf8) { + charSequence704 = (decoder).readString(((Utf8) oldString704)); + } else { + charSequence704 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(704, charSequence704); + } else { + throw new RuntimeException(("Illegal union index for 'F704': "+ unionIndex704)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex705 = (decoder.readIndex()); + if (unionIndex705 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(705, null); + } else { + if (unionIndex705 == 1) { + Utf8 charSequence705; + Object oldString705 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(705); + if (oldString705 instanceof Utf8) { + charSequence705 = (decoder).readString(((Utf8) oldString705)); + } else { + charSequence705 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(705, charSequence705); + } else { + throw new RuntimeException(("Illegal union index for 'F705': "+ unionIndex705)); + } + } + int unionIndex706 = (decoder.readIndex()); + if (unionIndex706 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(706, null); + } else { + if (unionIndex706 == 1) { + Utf8 charSequence706; + Object oldString706 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(706); + if (oldString706 instanceof Utf8) { + charSequence706 = (decoder).readString(((Utf8) oldString706)); + } else { + charSequence706 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(706, charSequence706); + } else { + throw new RuntimeException(("Illegal union index for 'F706': "+ unionIndex706)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex707 = (decoder.readIndex()); + if (unionIndex707 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(707, null); + } else { + if (unionIndex707 == 1) { + Utf8 charSequence707; + Object oldString707 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(707); + if (oldString707 instanceof Utf8) { + charSequence707 = (decoder).readString(((Utf8) oldString707)); + } else { + charSequence707 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(707, charSequence707); + } else { + throw new RuntimeException(("Illegal union index for 'F707': "+ unionIndex707)); + } + } + int unionIndex708 = (decoder.readIndex()); + if (unionIndex708 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(708, null); + } else { + if (unionIndex708 == 1) { + Utf8 charSequence708; + Object oldString708 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(708); + if (oldString708 instanceof Utf8) { + charSequence708 = (decoder).readString(((Utf8) oldString708)); + } else { + charSequence708 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(708, charSequence708); + } else { + throw new RuntimeException(("Illegal union index for 'F708': "+ unionIndex708)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex709 = (decoder.readIndex()); + if (unionIndex709 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(709, null); + } else { + if (unionIndex709 == 1) { + Utf8 charSequence709; + Object oldString709 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(709); + if (oldString709 instanceof Utf8) { + charSequence709 = (decoder).readString(((Utf8) oldString709)); + } else { + charSequence709 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(709, charSequence709); + } else { + throw new RuntimeException(("Illegal union index for 'F709': "+ unionIndex709)); + } + } + int unionIndex710 = (decoder.readIndex()); + if (unionIndex710 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(710, null); + } else { + if (unionIndex710 == 1) { + Utf8 charSequence710; + Object oldString710 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(710); + if (oldString710 instanceof Utf8) { + charSequence710 = (decoder).readString(((Utf8) oldString710)); + } else { + charSequence710 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(710, charSequence710); + } else { + throw new RuntimeException(("Illegal union index for 'F710': "+ unionIndex710)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex711 = (decoder.readIndex()); + if (unionIndex711 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(711, null); + } else { + if (unionIndex711 == 1) { + Utf8 charSequence711; + Object oldString711 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(711); + if (oldString711 instanceof Utf8) { + charSequence711 = (decoder).readString(((Utf8) oldString711)); + } else { + charSequence711 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(711, charSequence711); + } else { + throw new RuntimeException(("Illegal union index for 'F711': "+ unionIndex711)); + } + } + int unionIndex712 = (decoder.readIndex()); + if (unionIndex712 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(712, null); + } else { + if (unionIndex712 == 1) { + Utf8 charSequence712; + Object oldString712 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(712); + if (oldString712 instanceof Utf8) { + charSequence712 = (decoder).readString(((Utf8) oldString712)); + } else { + charSequence712 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(712, charSequence712); + } else { + throw new RuntimeException(("Illegal union index for 'F712': "+ unionIndex712)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex713 = (decoder.readIndex()); + if (unionIndex713 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(713, null); + } else { + if (unionIndex713 == 1) { + Utf8 charSequence713; + Object oldString713 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(713); + if (oldString713 instanceof Utf8) { + charSequence713 = (decoder).readString(((Utf8) oldString713)); + } else { + charSequence713 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(713, charSequence713); + } else { + throw new RuntimeException(("Illegal union index for 'F713': "+ unionIndex713)); + } + } + int unionIndex714 = (decoder.readIndex()); + if (unionIndex714 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(714, null); + } else { + if (unionIndex714 == 1) { + Utf8 charSequence714; + Object oldString714 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(714); + if (oldString714 instanceof Utf8) { + charSequence714 = (decoder).readString(((Utf8) oldString714)); + } else { + charSequence714 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(714, charSequence714); + } else { + throw new RuntimeException(("Illegal union index for 'F714': "+ unionIndex714)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex715 = (decoder.readIndex()); + if (unionIndex715 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(715, null); + } else { + if (unionIndex715 == 1) { + Utf8 charSequence715; + Object oldString715 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(715); + if (oldString715 instanceof Utf8) { + charSequence715 = (decoder).readString(((Utf8) oldString715)); + } else { + charSequence715 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(715, charSequence715); + } else { + throw new RuntimeException(("Illegal union index for 'F715': "+ unionIndex715)); + } + } + int unionIndex716 = (decoder.readIndex()); + if (unionIndex716 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(716, null); + } else { + if (unionIndex716 == 1) { + Utf8 charSequence716; + Object oldString716 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(716); + if (oldString716 instanceof Utf8) { + charSequence716 = (decoder).readString(((Utf8) oldString716)); + } else { + charSequence716 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(716, charSequence716); + } else { + throw new RuntimeException(("Illegal union index for 'F716': "+ unionIndex716)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex717 = (decoder.readIndex()); + if (unionIndex717 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(717, null); + } else { + if (unionIndex717 == 1) { + Utf8 charSequence717; + Object oldString717 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(717); + if (oldString717 instanceof Utf8) { + charSequence717 = (decoder).readString(((Utf8) oldString717)); + } else { + charSequence717 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(717, charSequence717); + } else { + throw new RuntimeException(("Illegal union index for 'F717': "+ unionIndex717)); + } + } + int unionIndex718 = (decoder.readIndex()); + if (unionIndex718 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(718, null); + } else { + if (unionIndex718 == 1) { + Utf8 charSequence718; + Object oldString718 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(718); + if (oldString718 instanceof Utf8) { + charSequence718 = (decoder).readString(((Utf8) oldString718)); + } else { + charSequence718 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(718, charSequence718); + } else { + throw new RuntimeException(("Illegal union index for 'F718': "+ unionIndex718)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex719 = (decoder.readIndex()); + if (unionIndex719 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(719, null); + } else { + if (unionIndex719 == 1) { + Utf8 charSequence719; + Object oldString719 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(719); + if (oldString719 instanceof Utf8) { + charSequence719 = (decoder).readString(((Utf8) oldString719)); + } else { + charSequence719 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(719, charSequence719); + } else { + throw new RuntimeException(("Illegal union index for 'F719': "+ unionIndex719)); + } + } + int unionIndex720 = (decoder.readIndex()); + if (unionIndex720 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(720, null); + } else { + if (unionIndex720 == 1) { + Utf8 charSequence720; + Object oldString720 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(720); + if (oldString720 instanceof Utf8) { + charSequence720 = (decoder).readString(((Utf8) oldString720)); + } else { + charSequence720 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(720, charSequence720); + } else { + throw new RuntimeException(("Illegal union index for 'F720': "+ unionIndex720)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex721 = (decoder.readIndex()); + if (unionIndex721 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(721, null); + } else { + if (unionIndex721 == 1) { + Utf8 charSequence721; + Object oldString721 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(721); + if (oldString721 instanceof Utf8) { + charSequence721 = (decoder).readString(((Utf8) oldString721)); + } else { + charSequence721 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(721, charSequence721); + } else { + throw new RuntimeException(("Illegal union index for 'F721': "+ unionIndex721)); + } + } + int unionIndex722 = (decoder.readIndex()); + if (unionIndex722 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(722, null); + } else { + if (unionIndex722 == 1) { + Utf8 charSequence722; + Object oldString722 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(722); + if (oldString722 instanceof Utf8) { + charSequence722 = (decoder).readString(((Utf8) oldString722)); + } else { + charSequence722 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(722, charSequence722); + } else { + throw new RuntimeException(("Illegal union index for 'F722': "+ unionIndex722)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex723 = (decoder.readIndex()); + if (unionIndex723 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(723, null); + } else { + if (unionIndex723 == 1) { + Utf8 charSequence723; + Object oldString723 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(723); + if (oldString723 instanceof Utf8) { + charSequence723 = (decoder).readString(((Utf8) oldString723)); + } else { + charSequence723 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(723, charSequence723); + } else { + throw new RuntimeException(("Illegal union index for 'F723': "+ unionIndex723)); + } + } + int unionIndex724 = (decoder.readIndex()); + if (unionIndex724 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(724, null); + } else { + if (unionIndex724 == 1) { + Utf8 charSequence724; + Object oldString724 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(724); + if (oldString724 instanceof Utf8) { + charSequence724 = (decoder).readString(((Utf8) oldString724)); + } else { + charSequence724 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(724, charSequence724); + } else { + throw new RuntimeException(("Illegal union index for 'F724': "+ unionIndex724)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex725 = (decoder.readIndex()); + if (unionIndex725 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(725, null); + } else { + if (unionIndex725 == 1) { + Utf8 charSequence725; + Object oldString725 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(725); + if (oldString725 instanceof Utf8) { + charSequence725 = (decoder).readString(((Utf8) oldString725)); + } else { + charSequence725 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(725, charSequence725); + } else { + throw new RuntimeException(("Illegal union index for 'F725': "+ unionIndex725)); + } + } + int unionIndex726 = (decoder.readIndex()); + if (unionIndex726 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(726, null); + } else { + if (unionIndex726 == 1) { + Utf8 charSequence726; + Object oldString726 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(726); + if (oldString726 instanceof Utf8) { + charSequence726 = (decoder).readString(((Utf8) oldString726)); + } else { + charSequence726 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(726, charSequence726); + } else { + throw new RuntimeException(("Illegal union index for 'F726': "+ unionIndex726)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex727 = (decoder.readIndex()); + if (unionIndex727 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(727, null); + } else { + if (unionIndex727 == 1) { + Utf8 charSequence727; + Object oldString727 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(727); + if (oldString727 instanceof Utf8) { + charSequence727 = (decoder).readString(((Utf8) oldString727)); + } else { + charSequence727 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(727, charSequence727); + } else { + throw new RuntimeException(("Illegal union index for 'F727': "+ unionIndex727)); + } + } + int unionIndex728 = (decoder.readIndex()); + if (unionIndex728 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(728, null); + } else { + if (unionIndex728 == 1) { + Utf8 charSequence728; + Object oldString728 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(728); + if (oldString728 instanceof Utf8) { + charSequence728 = (decoder).readString(((Utf8) oldString728)); + } else { + charSequence728 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(728, charSequence728); + } else { + throw new RuntimeException(("Illegal union index for 'F728': "+ unionIndex728)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex729 = (decoder.readIndex()); + if (unionIndex729 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(729, null); + } else { + if (unionIndex729 == 1) { + Utf8 charSequence729; + Object oldString729 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(729); + if (oldString729 instanceof Utf8) { + charSequence729 = (decoder).readString(((Utf8) oldString729)); + } else { + charSequence729 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(729, charSequence729); + } else { + throw new RuntimeException(("Illegal union index for 'F729': "+ unionIndex729)); + } + } + int unionIndex730 = (decoder.readIndex()); + if (unionIndex730 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(730, null); + } else { + if (unionIndex730 == 1) { + Utf8 charSequence730; + Object oldString730 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(730); + if (oldString730 instanceof Utf8) { + charSequence730 = (decoder).readString(((Utf8) oldString730)); + } else { + charSequence730 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(730, charSequence730); + } else { + throw new RuntimeException(("Illegal union index for 'F730': "+ unionIndex730)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex731 = (decoder.readIndex()); + if (unionIndex731 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(731, null); + } else { + if (unionIndex731 == 1) { + Utf8 charSequence731; + Object oldString731 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(731); + if (oldString731 instanceof Utf8) { + charSequence731 = (decoder).readString(((Utf8) oldString731)); + } else { + charSequence731 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(731, charSequence731); + } else { + throw new RuntimeException(("Illegal union index for 'F731': "+ unionIndex731)); + } + } + int unionIndex732 = (decoder.readIndex()); + if (unionIndex732 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(732, null); + } else { + if (unionIndex732 == 1) { + Utf8 charSequence732; + Object oldString732 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(732); + if (oldString732 instanceof Utf8) { + charSequence732 = (decoder).readString(((Utf8) oldString732)); + } else { + charSequence732 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(732, charSequence732); + } else { + throw new RuntimeException(("Illegal union index for 'F732': "+ unionIndex732)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex733 = (decoder.readIndex()); + if (unionIndex733 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(733, null); + } else { + if (unionIndex733 == 1) { + Utf8 charSequence733; + Object oldString733 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(733); + if (oldString733 instanceof Utf8) { + charSequence733 = (decoder).readString(((Utf8) oldString733)); + } else { + charSequence733 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(733, charSequence733); + } else { + throw new RuntimeException(("Illegal union index for 'F733': "+ unionIndex733)); + } + } + int unionIndex734 = (decoder.readIndex()); + if (unionIndex734 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(734, null); + } else { + if (unionIndex734 == 1) { + Utf8 charSequence734; + Object oldString734 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(734); + if (oldString734 instanceof Utf8) { + charSequence734 = (decoder).readString(((Utf8) oldString734)); + } else { + charSequence734 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(734, charSequence734); + } else { + throw new RuntimeException(("Illegal union index for 'F734': "+ unionIndex734)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex735 = (decoder.readIndex()); + if (unionIndex735 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(735, null); + } else { + if (unionIndex735 == 1) { + Utf8 charSequence735; + Object oldString735 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(735); + if (oldString735 instanceof Utf8) { + charSequence735 = (decoder).readString(((Utf8) oldString735)); + } else { + charSequence735 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(735, charSequence735); + } else { + throw new RuntimeException(("Illegal union index for 'F735': "+ unionIndex735)); + } + } + int unionIndex736 = (decoder.readIndex()); + if (unionIndex736 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(736, null); + } else { + if (unionIndex736 == 1) { + Utf8 charSequence736; + Object oldString736 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(736); + if (oldString736 instanceof Utf8) { + charSequence736 = (decoder).readString(((Utf8) oldString736)); + } else { + charSequence736 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(736, charSequence736); + } else { + throw new RuntimeException(("Illegal union index for 'F736': "+ unionIndex736)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex737 = (decoder.readIndex()); + if (unionIndex737 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(737, null); + } else { + if (unionIndex737 == 1) { + Utf8 charSequence737; + Object oldString737 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(737); + if (oldString737 instanceof Utf8) { + charSequence737 = (decoder).readString(((Utf8) oldString737)); + } else { + charSequence737 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(737, charSequence737); + } else { + throw new RuntimeException(("Illegal union index for 'F737': "+ unionIndex737)); + } + } + int unionIndex738 = (decoder.readIndex()); + if (unionIndex738 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(738, null); + } else { + if (unionIndex738 == 1) { + Utf8 charSequence738; + Object oldString738 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(738); + if (oldString738 instanceof Utf8) { + charSequence738 = (decoder).readString(((Utf8) oldString738)); + } else { + charSequence738 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(738, charSequence738); + } else { + throw new RuntimeException(("Illegal union index for 'F738': "+ unionIndex738)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex739 = (decoder.readIndex()); + if (unionIndex739 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(739, null); + } else { + if (unionIndex739 == 1) { + Utf8 charSequence739; + Object oldString739 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(739); + if (oldString739 instanceof Utf8) { + charSequence739 = (decoder).readString(((Utf8) oldString739)); + } else { + charSequence739 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(739, charSequence739); + } else { + throw new RuntimeException(("Illegal union index for 'F739': "+ unionIndex739)); + } + } + int unionIndex740 = (decoder.readIndex()); + if (unionIndex740 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(740, null); + } else { + if (unionIndex740 == 1) { + Utf8 charSequence740; + Object oldString740 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(740); + if (oldString740 instanceof Utf8) { + charSequence740 = (decoder).readString(((Utf8) oldString740)); + } else { + charSequence740 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(740, charSequence740); + } else { + throw new RuntimeException(("Illegal union index for 'F740': "+ unionIndex740)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex741 = (decoder.readIndex()); + if (unionIndex741 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(741, null); + } else { + if (unionIndex741 == 1) { + Utf8 charSequence741; + Object oldString741 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(741); + if (oldString741 instanceof Utf8) { + charSequence741 = (decoder).readString(((Utf8) oldString741)); + } else { + charSequence741 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(741, charSequence741); + } else { + throw new RuntimeException(("Illegal union index for 'F741': "+ unionIndex741)); + } + } + int unionIndex742 = (decoder.readIndex()); + if (unionIndex742 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(742, null); + } else { + if (unionIndex742 == 1) { + Utf8 charSequence742; + Object oldString742 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(742); + if (oldString742 instanceof Utf8) { + charSequence742 = (decoder).readString(((Utf8) oldString742)); + } else { + charSequence742 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(742, charSequence742); + } else { + throw new RuntimeException(("Illegal union index for 'F742': "+ unionIndex742)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex743 = (decoder.readIndex()); + if (unionIndex743 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(743, null); + } else { + if (unionIndex743 == 1) { + Utf8 charSequence743; + Object oldString743 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(743); + if (oldString743 instanceof Utf8) { + charSequence743 = (decoder).readString(((Utf8) oldString743)); + } else { + charSequence743 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(743, charSequence743); + } else { + throw new RuntimeException(("Illegal union index for 'F743': "+ unionIndex743)); + } + } + int unionIndex744 = (decoder.readIndex()); + if (unionIndex744 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(744, null); + } else { + if (unionIndex744 == 1) { + Utf8 charSequence744; + Object oldString744 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(744); + if (oldString744 instanceof Utf8) { + charSequence744 = (decoder).readString(((Utf8) oldString744)); + } else { + charSequence744 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(744, charSequence744); + } else { + throw new RuntimeException(("Illegal union index for 'F744': "+ unionIndex744)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex745 = (decoder.readIndex()); + if (unionIndex745 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(745, null); + } else { + if (unionIndex745 == 1) { + Utf8 charSequence745; + Object oldString745 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(745); + if (oldString745 instanceof Utf8) { + charSequence745 = (decoder).readString(((Utf8) oldString745)); + } else { + charSequence745 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(745, charSequence745); + } else { + throw new RuntimeException(("Illegal union index for 'F745': "+ unionIndex745)); + } + } + int unionIndex746 = (decoder.readIndex()); + if (unionIndex746 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(746, null); + } else { + if (unionIndex746 == 1) { + Utf8 charSequence746; + Object oldString746 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(746); + if (oldString746 instanceof Utf8) { + charSequence746 = (decoder).readString(((Utf8) oldString746)); + } else { + charSequence746 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(746, charSequence746); + } else { + throw new RuntimeException(("Illegal union index for 'F746': "+ unionIndex746)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex747 = (decoder.readIndex()); + if (unionIndex747 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(747, null); + } else { + if (unionIndex747 == 1) { + Utf8 charSequence747; + Object oldString747 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(747); + if (oldString747 instanceof Utf8) { + charSequence747 = (decoder).readString(((Utf8) oldString747)); + } else { + charSequence747 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(747, charSequence747); + } else { + throw new RuntimeException(("Illegal union index for 'F747': "+ unionIndex747)); + } + } + int unionIndex748 = (decoder.readIndex()); + if (unionIndex748 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(748, null); + } else { + if (unionIndex748 == 1) { + Utf8 charSequence748; + Object oldString748 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(748); + if (oldString748 instanceof Utf8) { + charSequence748 = (decoder).readString(((Utf8) oldString748)); + } else { + charSequence748 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(748, charSequence748); + } else { + throw new RuntimeException(("Illegal union index for 'F748': "+ unionIndex748)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex749 = (decoder.readIndex()); + if (unionIndex749 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(749, null); + } else { + if (unionIndex749 == 1) { + Utf8 charSequence749; + Object oldString749 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(749); + if (oldString749 instanceof Utf8) { + charSequence749 = (decoder).readString(((Utf8) oldString749)); + } else { + charSequence749 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(749, charSequence749); + } else { + throw new RuntimeException(("Illegal union index for 'F749': "+ unionIndex749)); + } + } + int unionIndex750 = (decoder.readIndex()); + if (unionIndex750 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(750, null); + } else { + if (unionIndex750 == 1) { + Utf8 charSequence750; + Object oldString750 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(750); + if (oldString750 instanceof Utf8) { + charSequence750 = (decoder).readString(((Utf8) oldString750)); + } else { + charSequence750 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(750, charSequence750); + } else { + throw new RuntimeException(("Illegal union index for 'F750': "+ unionIndex750)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex751 = (decoder.readIndex()); + if (unionIndex751 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(751, null); + } else { + if (unionIndex751 == 1) { + Utf8 charSequence751; + Object oldString751 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(751); + if (oldString751 instanceof Utf8) { + charSequence751 = (decoder).readString(((Utf8) oldString751)); + } else { + charSequence751 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(751, charSequence751); + } else { + throw new RuntimeException(("Illegal union index for 'F751': "+ unionIndex751)); + } + } + int unionIndex752 = (decoder.readIndex()); + if (unionIndex752 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(752, null); + } else { + if (unionIndex752 == 1) { + Utf8 charSequence752; + Object oldString752 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(752); + if (oldString752 instanceof Utf8) { + charSequence752 = (decoder).readString(((Utf8) oldString752)); + } else { + charSequence752 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(752, charSequence752); + } else { + throw new RuntimeException(("Illegal union index for 'F752': "+ unionIndex752)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex753 = (decoder.readIndex()); + if (unionIndex753 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(753, null); + } else { + if (unionIndex753 == 1) { + Utf8 charSequence753; + Object oldString753 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(753); + if (oldString753 instanceof Utf8) { + charSequence753 = (decoder).readString(((Utf8) oldString753)); + } else { + charSequence753 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(753, charSequence753); + } else { + throw new RuntimeException(("Illegal union index for 'F753': "+ unionIndex753)); + } + } + int unionIndex754 = (decoder.readIndex()); + if (unionIndex754 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(754, null); + } else { + if (unionIndex754 == 1) { + Utf8 charSequence754; + Object oldString754 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(754); + if (oldString754 instanceof Utf8) { + charSequence754 = (decoder).readString(((Utf8) oldString754)); + } else { + charSequence754 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(754, charSequence754); + } else { + throw new RuntimeException(("Illegal union index for 'F754': "+ unionIndex754)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex755 = (decoder.readIndex()); + if (unionIndex755 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(755, null); + } else { + if (unionIndex755 == 1) { + Utf8 charSequence755; + Object oldString755 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(755); + if (oldString755 instanceof Utf8) { + charSequence755 = (decoder).readString(((Utf8) oldString755)); + } else { + charSequence755 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(755, charSequence755); + } else { + throw new RuntimeException(("Illegal union index for 'F755': "+ unionIndex755)); + } + } + int unionIndex756 = (decoder.readIndex()); + if (unionIndex756 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(756, null); + } else { + if (unionIndex756 == 1) { + Utf8 charSequence756; + Object oldString756 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(756); + if (oldString756 instanceof Utf8) { + charSequence756 = (decoder).readString(((Utf8) oldString756)); + } else { + charSequence756 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(756, charSequence756); + } else { + throw new RuntimeException(("Illegal union index for 'F756': "+ unionIndex756)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex757 = (decoder.readIndex()); + if (unionIndex757 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(757, null); + } else { + if (unionIndex757 == 1) { + Utf8 charSequence757; + Object oldString757 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(757); + if (oldString757 instanceof Utf8) { + charSequence757 = (decoder).readString(((Utf8) oldString757)); + } else { + charSequence757 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(757, charSequence757); + } else { + throw new RuntimeException(("Illegal union index for 'F757': "+ unionIndex757)); + } + } + int unionIndex758 = (decoder.readIndex()); + if (unionIndex758 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(758, null); + } else { + if (unionIndex758 == 1) { + Utf8 charSequence758; + Object oldString758 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(758); + if (oldString758 instanceof Utf8) { + charSequence758 = (decoder).readString(((Utf8) oldString758)); + } else { + charSequence758 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(758, charSequence758); + } else { + throw new RuntimeException(("Illegal union index for 'F758': "+ unionIndex758)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex759 = (decoder.readIndex()); + if (unionIndex759 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(759, null); + } else { + if (unionIndex759 == 1) { + Utf8 charSequence759; + Object oldString759 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(759); + if (oldString759 instanceof Utf8) { + charSequence759 = (decoder).readString(((Utf8) oldString759)); + } else { + charSequence759 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(759, charSequence759); + } else { + throw new RuntimeException(("Illegal union index for 'F759': "+ unionIndex759)); + } + } + int unionIndex760 = (decoder.readIndex()); + if (unionIndex760 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(760, null); + } else { + if (unionIndex760 == 1) { + Utf8 charSequence760; + Object oldString760 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(760); + if (oldString760 instanceof Utf8) { + charSequence760 = (decoder).readString(((Utf8) oldString760)); + } else { + charSequence760 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(760, charSequence760); + } else { + throw new RuntimeException(("Illegal union index for 'F760': "+ unionIndex760)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex761 = (decoder.readIndex()); + if (unionIndex761 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(761, null); + } else { + if (unionIndex761 == 1) { + Utf8 charSequence761; + Object oldString761 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(761); + if (oldString761 instanceof Utf8) { + charSequence761 = (decoder).readString(((Utf8) oldString761)); + } else { + charSequence761 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(761, charSequence761); + } else { + throw new RuntimeException(("Illegal union index for 'F761': "+ unionIndex761)); + } + } + int unionIndex762 = (decoder.readIndex()); + if (unionIndex762 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(762, null); + } else { + if (unionIndex762 == 1) { + Utf8 charSequence762; + Object oldString762 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(762); + if (oldString762 instanceof Utf8) { + charSequence762 = (decoder).readString(((Utf8) oldString762)); + } else { + charSequence762 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(762, charSequence762); + } else { + throw new RuntimeException(("Illegal union index for 'F762': "+ unionIndex762)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex763 = (decoder.readIndex()); + if (unionIndex763 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(763, null); + } else { + if (unionIndex763 == 1) { + Utf8 charSequence763; + Object oldString763 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(763); + if (oldString763 instanceof Utf8) { + charSequence763 = (decoder).readString(((Utf8) oldString763)); + } else { + charSequence763 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(763, charSequence763); + } else { + throw new RuntimeException(("Illegal union index for 'F763': "+ unionIndex763)); + } + } + int unionIndex764 = (decoder.readIndex()); + if (unionIndex764 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(764, null); + } else { + if (unionIndex764 == 1) { + Utf8 charSequence764; + Object oldString764 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(764); + if (oldString764 instanceof Utf8) { + charSequence764 = (decoder).readString(((Utf8) oldString764)); + } else { + charSequence764 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(764, charSequence764); + } else { + throw new RuntimeException(("Illegal union index for 'F764': "+ unionIndex764)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex765 = (decoder.readIndex()); + if (unionIndex765 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(765, null); + } else { + if (unionIndex765 == 1) { + Utf8 charSequence765; + Object oldString765 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(765); + if (oldString765 instanceof Utf8) { + charSequence765 = (decoder).readString(((Utf8) oldString765)); + } else { + charSequence765 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(765, charSequence765); + } else { + throw new RuntimeException(("Illegal union index for 'F765': "+ unionIndex765)); + } + } + int unionIndex766 = (decoder.readIndex()); + if (unionIndex766 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(766, null); + } else { + if (unionIndex766 == 1) { + Utf8 charSequence766; + Object oldString766 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(766); + if (oldString766 instanceof Utf8) { + charSequence766 = (decoder).readString(((Utf8) oldString766)); + } else { + charSequence766 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(766, charSequence766); + } else { + throw new RuntimeException(("Illegal union index for 'F766': "+ unionIndex766)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex767 = (decoder.readIndex()); + if (unionIndex767 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(767, null); + } else { + if (unionIndex767 == 1) { + Utf8 charSequence767; + Object oldString767 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(767); + if (oldString767 instanceof Utf8) { + charSequence767 = (decoder).readString(((Utf8) oldString767)); + } else { + charSequence767 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(767, charSequence767); + } else { + throw new RuntimeException(("Illegal union index for 'F767': "+ unionIndex767)); + } + } + int unionIndex768 = (decoder.readIndex()); + if (unionIndex768 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(768, null); + } else { + if (unionIndex768 == 1) { + Utf8 charSequence768; + Object oldString768 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(768); + if (oldString768 instanceof Utf8) { + charSequence768 = (decoder).readString(((Utf8) oldString768)); + } else { + charSequence768 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(768, charSequence768); + } else { + throw new RuntimeException(("Illegal union index for 'F768': "+ unionIndex768)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex769 = (decoder.readIndex()); + if (unionIndex769 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(769, null); + } else { + if (unionIndex769 == 1) { + Utf8 charSequence769; + Object oldString769 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(769); + if (oldString769 instanceof Utf8) { + charSequence769 = (decoder).readString(((Utf8) oldString769)); + } else { + charSequence769 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(769, charSequence769); + } else { + throw new RuntimeException(("Illegal union index for 'F769': "+ unionIndex769)); + } + } + int unionIndex770 = (decoder.readIndex()); + if (unionIndex770 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(770, null); + } else { + if (unionIndex770 == 1) { + Utf8 charSequence770; + Object oldString770 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(770); + if (oldString770 instanceof Utf8) { + charSequence770 = (decoder).readString(((Utf8) oldString770)); + } else { + charSequence770 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(770, charSequence770); + } else { + throw new RuntimeException(("Illegal union index for 'F770': "+ unionIndex770)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex771 = (decoder.readIndex()); + if (unionIndex771 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(771, null); + } else { + if (unionIndex771 == 1) { + Utf8 charSequence771; + Object oldString771 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(771); + if (oldString771 instanceof Utf8) { + charSequence771 = (decoder).readString(((Utf8) oldString771)); + } else { + charSequence771 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(771, charSequence771); + } else { + throw new RuntimeException(("Illegal union index for 'F771': "+ unionIndex771)); + } + } + int unionIndex772 = (decoder.readIndex()); + if (unionIndex772 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(772, null); + } else { + if (unionIndex772 == 1) { + Utf8 charSequence772; + Object oldString772 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(772); + if (oldString772 instanceof Utf8) { + charSequence772 = (decoder).readString(((Utf8) oldString772)); + } else { + charSequence772 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(772, charSequence772); + } else { + throw new RuntimeException(("Illegal union index for 'F772': "+ unionIndex772)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex773 = (decoder.readIndex()); + if (unionIndex773 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(773, null); + } else { + if (unionIndex773 == 1) { + Utf8 charSequence773; + Object oldString773 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(773); + if (oldString773 instanceof Utf8) { + charSequence773 = (decoder).readString(((Utf8) oldString773)); + } else { + charSequence773 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(773, charSequence773); + } else { + throw new RuntimeException(("Illegal union index for 'F773': "+ unionIndex773)); + } + } + int unionIndex774 = (decoder.readIndex()); + if (unionIndex774 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(774, null); + } else { + if (unionIndex774 == 1) { + Utf8 charSequence774; + Object oldString774 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(774); + if (oldString774 instanceof Utf8) { + charSequence774 = (decoder).readString(((Utf8) oldString774)); + } else { + charSequence774 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(774, charSequence774); + } else { + throw new RuntimeException(("Illegal union index for 'F774': "+ unionIndex774)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex775 = (decoder.readIndex()); + if (unionIndex775 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(775, null); + } else { + if (unionIndex775 == 1) { + Utf8 charSequence775; + Object oldString775 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(775); + if (oldString775 instanceof Utf8) { + charSequence775 = (decoder).readString(((Utf8) oldString775)); + } else { + charSequence775 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(775, charSequence775); + } else { + throw new RuntimeException(("Illegal union index for 'F775': "+ unionIndex775)); + } + } + int unionIndex776 = (decoder.readIndex()); + if (unionIndex776 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(776, null); + } else { + if (unionIndex776 == 1) { + Utf8 charSequence776; + Object oldString776 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(776); + if (oldString776 instanceof Utf8) { + charSequence776 = (decoder).readString(((Utf8) oldString776)); + } else { + charSequence776 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(776, charSequence776); + } else { + throw new RuntimeException(("Illegal union index for 'F776': "+ unionIndex776)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex777 = (decoder.readIndex()); + if (unionIndex777 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(777, null); + } else { + if (unionIndex777 == 1) { + Utf8 charSequence777; + Object oldString777 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(777); + if (oldString777 instanceof Utf8) { + charSequence777 = (decoder).readString(((Utf8) oldString777)); + } else { + charSequence777 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(777, charSequence777); + } else { + throw new RuntimeException(("Illegal union index for 'F777': "+ unionIndex777)); + } + } + int unionIndex778 = (decoder.readIndex()); + if (unionIndex778 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(778, null); + } else { + if (unionIndex778 == 1) { + Utf8 charSequence778; + Object oldString778 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(778); + if (oldString778 instanceof Utf8) { + charSequence778 = (decoder).readString(((Utf8) oldString778)); + } else { + charSequence778 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(778, charSequence778); + } else { + throw new RuntimeException(("Illegal union index for 'F778': "+ unionIndex778)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex779 = (decoder.readIndex()); + if (unionIndex779 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(779, null); + } else { + if (unionIndex779 == 1) { + Utf8 charSequence779; + Object oldString779 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(779); + if (oldString779 instanceof Utf8) { + charSequence779 = (decoder).readString(((Utf8) oldString779)); + } else { + charSequence779 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(779, charSequence779); + } else { + throw new RuntimeException(("Illegal union index for 'F779': "+ unionIndex779)); + } + } + int unionIndex780 = (decoder.readIndex()); + if (unionIndex780 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(780, null); + } else { + if (unionIndex780 == 1) { + Utf8 charSequence780; + Object oldString780 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(780); + if (oldString780 instanceof Utf8) { + charSequence780 = (decoder).readString(((Utf8) oldString780)); + } else { + charSequence780 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(780, charSequence780); + } else { + throw new RuntimeException(("Illegal union index for 'F780': "+ unionIndex780)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex781 = (decoder.readIndex()); + if (unionIndex781 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(781, null); + } else { + if (unionIndex781 == 1) { + Utf8 charSequence781; + Object oldString781 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(781); + if (oldString781 instanceof Utf8) { + charSequence781 = (decoder).readString(((Utf8) oldString781)); + } else { + charSequence781 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(781, charSequence781); + } else { + throw new RuntimeException(("Illegal union index for 'F781': "+ unionIndex781)); + } + } + int unionIndex782 = (decoder.readIndex()); + if (unionIndex782 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(782, null); + } else { + if (unionIndex782 == 1) { + Utf8 charSequence782; + Object oldString782 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(782); + if (oldString782 instanceof Utf8) { + charSequence782 = (decoder).readString(((Utf8) oldString782)); + } else { + charSequence782 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(782, charSequence782); + } else { + throw new RuntimeException(("Illegal union index for 'F782': "+ unionIndex782)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex783 = (decoder.readIndex()); + if (unionIndex783 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(783, null); + } else { + if (unionIndex783 == 1) { + Utf8 charSequence783; + Object oldString783 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(783); + if (oldString783 instanceof Utf8) { + charSequence783 = (decoder).readString(((Utf8) oldString783)); + } else { + charSequence783 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(783, charSequence783); + } else { + throw new RuntimeException(("Illegal union index for 'F783': "+ unionIndex783)); + } + } + int unionIndex784 = (decoder.readIndex()); + if (unionIndex784 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(784, null); + } else { + if (unionIndex784 == 1) { + Utf8 charSequence784; + Object oldString784 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(784); + if (oldString784 instanceof Utf8) { + charSequence784 = (decoder).readString(((Utf8) oldString784)); + } else { + charSequence784 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(784, charSequence784); + } else { + throw new RuntimeException(("Illegal union index for 'F784': "+ unionIndex784)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex785 = (decoder.readIndex()); + if (unionIndex785 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(785, null); + } else { + if (unionIndex785 == 1) { + Utf8 charSequence785; + Object oldString785 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(785); + if (oldString785 instanceof Utf8) { + charSequence785 = (decoder).readString(((Utf8) oldString785)); + } else { + charSequence785 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(785, charSequence785); + } else { + throw new RuntimeException(("Illegal union index for 'F785': "+ unionIndex785)); + } + } + int unionIndex786 = (decoder.readIndex()); + if (unionIndex786 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(786, null); + } else { + if (unionIndex786 == 1) { + Utf8 charSequence786; + Object oldString786 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(786); + if (oldString786 instanceof Utf8) { + charSequence786 = (decoder).readString(((Utf8) oldString786)); + } else { + charSequence786 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(786, charSequence786); + } else { + throw new RuntimeException(("Illegal union index for 'F786': "+ unionIndex786)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex787 = (decoder.readIndex()); + if (unionIndex787 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(787, null); + } else { + if (unionIndex787 == 1) { + Utf8 charSequence787; + Object oldString787 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(787); + if (oldString787 instanceof Utf8) { + charSequence787 = (decoder).readString(((Utf8) oldString787)); + } else { + charSequence787 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(787, charSequence787); + } else { + throw new RuntimeException(("Illegal union index for 'F787': "+ unionIndex787)); + } + } + int unionIndex788 = (decoder.readIndex()); + if (unionIndex788 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(788, null); + } else { + if (unionIndex788 == 1) { + Utf8 charSequence788; + Object oldString788 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(788); + if (oldString788 instanceof Utf8) { + charSequence788 = (decoder).readString(((Utf8) oldString788)); + } else { + charSequence788 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(788, charSequence788); + } else { + throw new RuntimeException(("Illegal union index for 'F788': "+ unionIndex788)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex789 = (decoder.readIndex()); + if (unionIndex789 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(789, null); + } else { + if (unionIndex789 == 1) { + Utf8 charSequence789; + Object oldString789 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(789); + if (oldString789 instanceof Utf8) { + charSequence789 = (decoder).readString(((Utf8) oldString789)); + } else { + charSequence789 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(789, charSequence789); + } else { + throw new RuntimeException(("Illegal union index for 'F789': "+ unionIndex789)); + } + } + int unionIndex790 = (decoder.readIndex()); + if (unionIndex790 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(790, null); + } else { + if (unionIndex790 == 1) { + Utf8 charSequence790; + Object oldString790 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(790); + if (oldString790 instanceof Utf8) { + charSequence790 = (decoder).readString(((Utf8) oldString790)); + } else { + charSequence790 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(790, charSequence790); + } else { + throw new RuntimeException(("Illegal union index for 'F790': "+ unionIndex790)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex791 = (decoder.readIndex()); + if (unionIndex791 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(791, null); + } else { + if (unionIndex791 == 1) { + Utf8 charSequence791; + Object oldString791 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(791); + if (oldString791 instanceof Utf8) { + charSequence791 = (decoder).readString(((Utf8) oldString791)); + } else { + charSequence791 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(791, charSequence791); + } else { + throw new RuntimeException(("Illegal union index for 'F791': "+ unionIndex791)); + } + } + int unionIndex792 = (decoder.readIndex()); + if (unionIndex792 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(792, null); + } else { + if (unionIndex792 == 1) { + Utf8 charSequence792; + Object oldString792 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(792); + if (oldString792 instanceof Utf8) { + charSequence792 = (decoder).readString(((Utf8) oldString792)); + } else { + charSequence792 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(792, charSequence792); + } else { + throw new RuntimeException(("Illegal union index for 'F792': "+ unionIndex792)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex793 = (decoder.readIndex()); + if (unionIndex793 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(793, null); + } else { + if (unionIndex793 == 1) { + Utf8 charSequence793; + Object oldString793 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(793); + if (oldString793 instanceof Utf8) { + charSequence793 = (decoder).readString(((Utf8) oldString793)); + } else { + charSequence793 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(793, charSequence793); + } else { + throw new RuntimeException(("Illegal union index for 'F793': "+ unionIndex793)); + } + } + int unionIndex794 = (decoder.readIndex()); + if (unionIndex794 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(794, null); + } else { + if (unionIndex794 == 1) { + Utf8 charSequence794; + Object oldString794 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(794); + if (oldString794 instanceof Utf8) { + charSequence794 = (decoder).readString(((Utf8) oldString794)); + } else { + charSequence794 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(794, charSequence794); + } else { + throw new RuntimeException(("Illegal union index for 'F794': "+ unionIndex794)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex795 = (decoder.readIndex()); + if (unionIndex795 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(795, null); + } else { + if (unionIndex795 == 1) { + Utf8 charSequence795; + Object oldString795 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(795); + if (oldString795 instanceof Utf8) { + charSequence795 = (decoder).readString(((Utf8) oldString795)); + } else { + charSequence795 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(795, charSequence795); + } else { + throw new RuntimeException(("Illegal union index for 'F795': "+ unionIndex795)); + } + } + int unionIndex796 = (decoder.readIndex()); + if (unionIndex796 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(796, null); + } else { + if (unionIndex796 == 1) { + Utf8 charSequence796; + Object oldString796 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(796); + if (oldString796 instanceof Utf8) { + charSequence796 = (decoder).readString(((Utf8) oldString796)); + } else { + charSequence796 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(796, charSequence796); + } else { + throw new RuntimeException(("Illegal union index for 'F796': "+ unionIndex796)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex797 = (decoder.readIndex()); + if (unionIndex797 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(797, null); + } else { + if (unionIndex797 == 1) { + Utf8 charSequence797; + Object oldString797 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(797); + if (oldString797 instanceof Utf8) { + charSequence797 = (decoder).readString(((Utf8) oldString797)); + } else { + charSequence797 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(797, charSequence797); + } else { + throw new RuntimeException(("Illegal union index for 'F797': "+ unionIndex797)); + } + } + int unionIndex798 = (decoder.readIndex()); + if (unionIndex798 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(798, null); + } else { + if (unionIndex798 == 1) { + Utf8 charSequence798; + Object oldString798 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(798); + if (oldString798 instanceof Utf8) { + charSequence798 = (decoder).readString(((Utf8) oldString798)); + } else { + charSequence798 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(798, charSequence798); + } else { + throw new RuntimeException(("Illegal union index for 'F798': "+ unionIndex798)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex799 = (decoder.readIndex()); + if (unionIndex799 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(799, null); + } else { + if (unionIndex799 == 1) { + Utf8 charSequence799; + Object oldString799 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(799); + if (oldString799 instanceof Utf8) { + charSequence799 = (decoder).readString(((Utf8) oldString799)); + } else { + charSequence799 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(799, charSequence799); + } else { + throw new RuntimeException(("Illegal union index for 'F799': "+ unionIndex799)); + } + } + int unionIndex800 = (decoder.readIndex()); + if (unionIndex800 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(800, null); + } else { + if (unionIndex800 == 1) { + Utf8 charSequence800; + Object oldString800 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(800); + if (oldString800 instanceof Utf8) { + charSequence800 = (decoder).readString(((Utf8) oldString800)); + } else { + charSequence800 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(800, charSequence800); + } else { + throw new RuntimeException(("Illegal union index for 'F800': "+ unionIndex800)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex801 = (decoder.readIndex()); + if (unionIndex801 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(801, null); + } else { + if (unionIndex801 == 1) { + Utf8 charSequence801; + Object oldString801 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(801); + if (oldString801 instanceof Utf8) { + charSequence801 = (decoder).readString(((Utf8) oldString801)); + } else { + charSequence801 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(801, charSequence801); + } else { + throw new RuntimeException(("Illegal union index for 'F801': "+ unionIndex801)); + } + } + int unionIndex802 = (decoder.readIndex()); + if (unionIndex802 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(802, null); + } else { + if (unionIndex802 == 1) { + Utf8 charSequence802; + Object oldString802 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(802); + if (oldString802 instanceof Utf8) { + charSequence802 = (decoder).readString(((Utf8) oldString802)); + } else { + charSequence802 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(802, charSequence802); + } else { + throw new RuntimeException(("Illegal union index for 'F802': "+ unionIndex802)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex803 = (decoder.readIndex()); + if (unionIndex803 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(803, null); + } else { + if (unionIndex803 == 1) { + Utf8 charSequence803; + Object oldString803 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(803); + if (oldString803 instanceof Utf8) { + charSequence803 = (decoder).readString(((Utf8) oldString803)); + } else { + charSequence803 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(803, charSequence803); + } else { + throw new RuntimeException(("Illegal union index for 'F803': "+ unionIndex803)); + } + } + int unionIndex804 = (decoder.readIndex()); + if (unionIndex804 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(804, null); + } else { + if (unionIndex804 == 1) { + Utf8 charSequence804; + Object oldString804 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(804); + if (oldString804 instanceof Utf8) { + charSequence804 = (decoder).readString(((Utf8) oldString804)); + } else { + charSequence804 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(804, charSequence804); + } else { + throw new RuntimeException(("Illegal union index for 'F804': "+ unionIndex804)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex805 = (decoder.readIndex()); + if (unionIndex805 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(805, null); + } else { + if (unionIndex805 == 1) { + Utf8 charSequence805; + Object oldString805 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(805); + if (oldString805 instanceof Utf8) { + charSequence805 = (decoder).readString(((Utf8) oldString805)); + } else { + charSequence805 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(805, charSequence805); + } else { + throw new RuntimeException(("Illegal union index for 'F805': "+ unionIndex805)); + } + } + int unionIndex806 = (decoder.readIndex()); + if (unionIndex806 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(806, null); + } else { + if (unionIndex806 == 1) { + Utf8 charSequence806; + Object oldString806 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(806); + if (oldString806 instanceof Utf8) { + charSequence806 = (decoder).readString(((Utf8) oldString806)); + } else { + charSequence806 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(806, charSequence806); + } else { + throw new RuntimeException(("Illegal union index for 'F806': "+ unionIndex806)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex807 = (decoder.readIndex()); + if (unionIndex807 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(807, null); + } else { + if (unionIndex807 == 1) { + Utf8 charSequence807; + Object oldString807 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(807); + if (oldString807 instanceof Utf8) { + charSequence807 = (decoder).readString(((Utf8) oldString807)); + } else { + charSequence807 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(807, charSequence807); + } else { + throw new RuntimeException(("Illegal union index for 'F807': "+ unionIndex807)); + } + } + int unionIndex808 = (decoder.readIndex()); + if (unionIndex808 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(808, null); + } else { + if (unionIndex808 == 1) { + Utf8 charSequence808; + Object oldString808 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(808); + if (oldString808 instanceof Utf8) { + charSequence808 = (decoder).readString(((Utf8) oldString808)); + } else { + charSequence808 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(808, charSequence808); + } else { + throw new RuntimeException(("Illegal union index for 'F808': "+ unionIndex808)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex809 = (decoder.readIndex()); + if (unionIndex809 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(809, null); + } else { + if (unionIndex809 == 1) { + Utf8 charSequence809; + Object oldString809 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(809); + if (oldString809 instanceof Utf8) { + charSequence809 = (decoder).readString(((Utf8) oldString809)); + } else { + charSequence809 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(809, charSequence809); + } else { + throw new RuntimeException(("Illegal union index for 'F809': "+ unionIndex809)); + } + } + int unionIndex810 = (decoder.readIndex()); + if (unionIndex810 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(810, null); + } else { + if (unionIndex810 == 1) { + Utf8 charSequence810; + Object oldString810 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(810); + if (oldString810 instanceof Utf8) { + charSequence810 = (decoder).readString(((Utf8) oldString810)); + } else { + charSequence810 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(810, charSequence810); + } else { + throw new RuntimeException(("Illegal union index for 'F810': "+ unionIndex810)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex811 = (decoder.readIndex()); + if (unionIndex811 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(811, null); + } else { + if (unionIndex811 == 1) { + Utf8 charSequence811; + Object oldString811 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(811); + if (oldString811 instanceof Utf8) { + charSequence811 = (decoder).readString(((Utf8) oldString811)); + } else { + charSequence811 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(811, charSequence811); + } else { + throw new RuntimeException(("Illegal union index for 'F811': "+ unionIndex811)); + } + } + int unionIndex812 = (decoder.readIndex()); + if (unionIndex812 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(812, null); + } else { + if (unionIndex812 == 1) { + Utf8 charSequence812; + Object oldString812 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(812); + if (oldString812 instanceof Utf8) { + charSequence812 = (decoder).readString(((Utf8) oldString812)); + } else { + charSequence812 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(812, charSequence812); + } else { + throw new RuntimeException(("Illegal union index for 'F812': "+ unionIndex812)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex813 = (decoder.readIndex()); + if (unionIndex813 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(813, null); + } else { + if (unionIndex813 == 1) { + Utf8 charSequence813; + Object oldString813 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(813); + if (oldString813 instanceof Utf8) { + charSequence813 = (decoder).readString(((Utf8) oldString813)); + } else { + charSequence813 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(813, charSequence813); + } else { + throw new RuntimeException(("Illegal union index for 'F813': "+ unionIndex813)); + } + } + int unionIndex814 = (decoder.readIndex()); + if (unionIndex814 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(814, null); + } else { + if (unionIndex814 == 1) { + Utf8 charSequence814; + Object oldString814 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(814); + if (oldString814 instanceof Utf8) { + charSequence814 = (decoder).readString(((Utf8) oldString814)); + } else { + charSequence814 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(814, charSequence814); + } else { + throw new RuntimeException(("Illegal union index for 'F814': "+ unionIndex814)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex815 = (decoder.readIndex()); + if (unionIndex815 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(815, null); + } else { + if (unionIndex815 == 1) { + Utf8 charSequence815; + Object oldString815 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(815); + if (oldString815 instanceof Utf8) { + charSequence815 = (decoder).readString(((Utf8) oldString815)); + } else { + charSequence815 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(815, charSequence815); + } else { + throw new RuntimeException(("Illegal union index for 'F815': "+ unionIndex815)); + } + } + int unionIndex816 = (decoder.readIndex()); + if (unionIndex816 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(816, null); + } else { + if (unionIndex816 == 1) { + Utf8 charSequence816; + Object oldString816 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(816); + if (oldString816 instanceof Utf8) { + charSequence816 = (decoder).readString(((Utf8) oldString816)); + } else { + charSequence816 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(816, charSequence816); + } else { + throw new RuntimeException(("Illegal union index for 'F816': "+ unionIndex816)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex817 = (decoder.readIndex()); + if (unionIndex817 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(817, null); + } else { + if (unionIndex817 == 1) { + Utf8 charSequence817; + Object oldString817 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(817); + if (oldString817 instanceof Utf8) { + charSequence817 = (decoder).readString(((Utf8) oldString817)); + } else { + charSequence817 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(817, charSequence817); + } else { + throw new RuntimeException(("Illegal union index for 'F817': "+ unionIndex817)); + } + } + int unionIndex818 = (decoder.readIndex()); + if (unionIndex818 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(818, null); + } else { + if (unionIndex818 == 1) { + Utf8 charSequence818; + Object oldString818 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(818); + if (oldString818 instanceof Utf8) { + charSequence818 = (decoder).readString(((Utf8) oldString818)); + } else { + charSequence818 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(818, charSequence818); + } else { + throw new RuntimeException(("Illegal union index for 'F818': "+ unionIndex818)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex819 = (decoder.readIndex()); + if (unionIndex819 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(819, null); + } else { + if (unionIndex819 == 1) { + Utf8 charSequence819; + Object oldString819 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(819); + if (oldString819 instanceof Utf8) { + charSequence819 = (decoder).readString(((Utf8) oldString819)); + } else { + charSequence819 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(819, charSequence819); + } else { + throw new RuntimeException(("Illegal union index for 'F819': "+ unionIndex819)); + } + } + int unionIndex820 = (decoder.readIndex()); + if (unionIndex820 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(820, null); + } else { + if (unionIndex820 == 1) { + Utf8 charSequence820; + Object oldString820 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(820); + if (oldString820 instanceof Utf8) { + charSequence820 = (decoder).readString(((Utf8) oldString820)); + } else { + charSequence820 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(820, charSequence820); + } else { + throw new RuntimeException(("Illegal union index for 'F820': "+ unionIndex820)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex821 = (decoder.readIndex()); + if (unionIndex821 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(821, null); + } else { + if (unionIndex821 == 1) { + Utf8 charSequence821; + Object oldString821 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(821); + if (oldString821 instanceof Utf8) { + charSequence821 = (decoder).readString(((Utf8) oldString821)); + } else { + charSequence821 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(821, charSequence821); + } else { + throw new RuntimeException(("Illegal union index for 'F821': "+ unionIndex821)); + } + } + int unionIndex822 = (decoder.readIndex()); + if (unionIndex822 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(822, null); + } else { + if (unionIndex822 == 1) { + Utf8 charSequence822; + Object oldString822 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(822); + if (oldString822 instanceof Utf8) { + charSequence822 = (decoder).readString(((Utf8) oldString822)); + } else { + charSequence822 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(822, charSequence822); + } else { + throw new RuntimeException(("Illegal union index for 'F822': "+ unionIndex822)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex823 = (decoder.readIndex()); + if (unionIndex823 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(823, null); + } else { + if (unionIndex823 == 1) { + Utf8 charSequence823; + Object oldString823 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(823); + if (oldString823 instanceof Utf8) { + charSequence823 = (decoder).readString(((Utf8) oldString823)); + } else { + charSequence823 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(823, charSequence823); + } else { + throw new RuntimeException(("Illegal union index for 'F823': "+ unionIndex823)); + } + } + int unionIndex824 = (decoder.readIndex()); + if (unionIndex824 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(824, null); + } else { + if (unionIndex824 == 1) { + Utf8 charSequence824; + Object oldString824 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(824); + if (oldString824 instanceof Utf8) { + charSequence824 = (decoder).readString(((Utf8) oldString824)); + } else { + charSequence824 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(824, charSequence824); + } else { + throw new RuntimeException(("Illegal union index for 'F824': "+ unionIndex824)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex825 = (decoder.readIndex()); + if (unionIndex825 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(825, null); + } else { + if (unionIndex825 == 1) { + Utf8 charSequence825; + Object oldString825 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(825); + if (oldString825 instanceof Utf8) { + charSequence825 = (decoder).readString(((Utf8) oldString825)); + } else { + charSequence825 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(825, charSequence825); + } else { + throw new RuntimeException(("Illegal union index for 'F825': "+ unionIndex825)); + } + } + int unionIndex826 = (decoder.readIndex()); + if (unionIndex826 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(826, null); + } else { + if (unionIndex826 == 1) { + Utf8 charSequence826; + Object oldString826 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(826); + if (oldString826 instanceof Utf8) { + charSequence826 = (decoder).readString(((Utf8) oldString826)); + } else { + charSequence826 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(826, charSequence826); + } else { + throw new RuntimeException(("Illegal union index for 'F826': "+ unionIndex826)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex827 = (decoder.readIndex()); + if (unionIndex827 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(827, null); + } else { + if (unionIndex827 == 1) { + Utf8 charSequence827; + Object oldString827 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(827); + if (oldString827 instanceof Utf8) { + charSequence827 = (decoder).readString(((Utf8) oldString827)); + } else { + charSequence827 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(827, charSequence827); + } else { + throw new RuntimeException(("Illegal union index for 'F827': "+ unionIndex827)); + } + } + int unionIndex828 = (decoder.readIndex()); + if (unionIndex828 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(828, null); + } else { + if (unionIndex828 == 1) { + Utf8 charSequence828; + Object oldString828 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(828); + if (oldString828 instanceof Utf8) { + charSequence828 = (decoder).readString(((Utf8) oldString828)); + } else { + charSequence828 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(828, charSequence828); + } else { + throw new RuntimeException(("Illegal union index for 'F828': "+ unionIndex828)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex829 = (decoder.readIndex()); + if (unionIndex829 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(829, null); + } else { + if (unionIndex829 == 1) { + Utf8 charSequence829; + Object oldString829 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(829); + if (oldString829 instanceof Utf8) { + charSequence829 = (decoder).readString(((Utf8) oldString829)); + } else { + charSequence829 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(829, charSequence829); + } else { + throw new RuntimeException(("Illegal union index for 'F829': "+ unionIndex829)); + } + } + int unionIndex830 = (decoder.readIndex()); + if (unionIndex830 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(830, null); + } else { + if (unionIndex830 == 1) { + Utf8 charSequence830; + Object oldString830 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(830); + if (oldString830 instanceof Utf8) { + charSequence830 = (decoder).readString(((Utf8) oldString830)); + } else { + charSequence830 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(830, charSequence830); + } else { + throw new RuntimeException(("Illegal union index for 'F830': "+ unionIndex830)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex831 = (decoder.readIndex()); + if (unionIndex831 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(831, null); + } else { + if (unionIndex831 == 1) { + Utf8 charSequence831; + Object oldString831 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(831); + if (oldString831 instanceof Utf8) { + charSequence831 = (decoder).readString(((Utf8) oldString831)); + } else { + charSequence831 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(831, charSequence831); + } else { + throw new RuntimeException(("Illegal union index for 'F831': "+ unionIndex831)); + } + } + int unionIndex832 = (decoder.readIndex()); + if (unionIndex832 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(832, null); + } else { + if (unionIndex832 == 1) { + Utf8 charSequence832; + Object oldString832 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(832); + if (oldString832 instanceof Utf8) { + charSequence832 = (decoder).readString(((Utf8) oldString832)); + } else { + charSequence832 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(832, charSequence832); + } else { + throw new RuntimeException(("Illegal union index for 'F832': "+ unionIndex832)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex833 = (decoder.readIndex()); + if (unionIndex833 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(833, null); + } else { + if (unionIndex833 == 1) { + Utf8 charSequence833; + Object oldString833 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(833); + if (oldString833 instanceof Utf8) { + charSequence833 = (decoder).readString(((Utf8) oldString833)); + } else { + charSequence833 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(833, charSequence833); + } else { + throw new RuntimeException(("Illegal union index for 'F833': "+ unionIndex833)); + } + } + int unionIndex834 = (decoder.readIndex()); + if (unionIndex834 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(834, null); + } else { + if (unionIndex834 == 1) { + Utf8 charSequence834; + Object oldString834 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(834); + if (oldString834 instanceof Utf8) { + charSequence834 = (decoder).readString(((Utf8) oldString834)); + } else { + charSequence834 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(834, charSequence834); + } else { + throw new RuntimeException(("Illegal union index for 'F834': "+ unionIndex834)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex835 = (decoder.readIndex()); + if (unionIndex835 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(835, null); + } else { + if (unionIndex835 == 1) { + Utf8 charSequence835; + Object oldString835 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(835); + if (oldString835 instanceof Utf8) { + charSequence835 = (decoder).readString(((Utf8) oldString835)); + } else { + charSequence835 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(835, charSequence835); + } else { + throw new RuntimeException(("Illegal union index for 'F835': "+ unionIndex835)); + } + } + int unionIndex836 = (decoder.readIndex()); + if (unionIndex836 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(836, null); + } else { + if (unionIndex836 == 1) { + Utf8 charSequence836; + Object oldString836 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(836); + if (oldString836 instanceof Utf8) { + charSequence836 = (decoder).readString(((Utf8) oldString836)); + } else { + charSequence836 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(836, charSequence836); + } else { + throw new RuntimeException(("Illegal union index for 'F836': "+ unionIndex836)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex837 = (decoder.readIndex()); + if (unionIndex837 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(837, null); + } else { + if (unionIndex837 == 1) { + Utf8 charSequence837; + Object oldString837 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(837); + if (oldString837 instanceof Utf8) { + charSequence837 = (decoder).readString(((Utf8) oldString837)); + } else { + charSequence837 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(837, charSequence837); + } else { + throw new RuntimeException(("Illegal union index for 'F837': "+ unionIndex837)); + } + } + int unionIndex838 = (decoder.readIndex()); + if (unionIndex838 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(838, null); + } else { + if (unionIndex838 == 1) { + Utf8 charSequence838; + Object oldString838 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(838); + if (oldString838 instanceof Utf8) { + charSequence838 = (decoder).readString(((Utf8) oldString838)); + } else { + charSequence838 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(838, charSequence838); + } else { + throw new RuntimeException(("Illegal union index for 'F838': "+ unionIndex838)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex839 = (decoder.readIndex()); + if (unionIndex839 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(839, null); + } else { + if (unionIndex839 == 1) { + Utf8 charSequence839; + Object oldString839 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(839); + if (oldString839 instanceof Utf8) { + charSequence839 = (decoder).readString(((Utf8) oldString839)); + } else { + charSequence839 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(839, charSequence839); + } else { + throw new RuntimeException(("Illegal union index for 'F839': "+ unionIndex839)); + } + } + int unionIndex840 = (decoder.readIndex()); + if (unionIndex840 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(840, null); + } else { + if (unionIndex840 == 1) { + Utf8 charSequence840; + Object oldString840 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(840); + if (oldString840 instanceof Utf8) { + charSequence840 = (decoder).readString(((Utf8) oldString840)); + } else { + charSequence840 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(840, charSequence840); + } else { + throw new RuntimeException(("Illegal union index for 'F840': "+ unionIndex840)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex841 = (decoder.readIndex()); + if (unionIndex841 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(841, null); + } else { + if (unionIndex841 == 1) { + Utf8 charSequence841; + Object oldString841 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(841); + if (oldString841 instanceof Utf8) { + charSequence841 = (decoder).readString(((Utf8) oldString841)); + } else { + charSequence841 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(841, charSequence841); + } else { + throw new RuntimeException(("Illegal union index for 'F841': "+ unionIndex841)); + } + } + int unionIndex842 = (decoder.readIndex()); + if (unionIndex842 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(842, null); + } else { + if (unionIndex842 == 1) { + Utf8 charSequence842; + Object oldString842 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(842); + if (oldString842 instanceof Utf8) { + charSequence842 = (decoder).readString(((Utf8) oldString842)); + } else { + charSequence842 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(842, charSequence842); + } else { + throw new RuntimeException(("Illegal union index for 'F842': "+ unionIndex842)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex843 = (decoder.readIndex()); + if (unionIndex843 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(843, null); + } else { + if (unionIndex843 == 1) { + Utf8 charSequence843; + Object oldString843 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(843); + if (oldString843 instanceof Utf8) { + charSequence843 = (decoder).readString(((Utf8) oldString843)); + } else { + charSequence843 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(843, charSequence843); + } else { + throw new RuntimeException(("Illegal union index for 'F843': "+ unionIndex843)); + } + } + int unionIndex844 = (decoder.readIndex()); + if (unionIndex844 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(844, null); + } else { + if (unionIndex844 == 1) { + Utf8 charSequence844; + Object oldString844 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(844); + if (oldString844 instanceof Utf8) { + charSequence844 = (decoder).readString(((Utf8) oldString844)); + } else { + charSequence844 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(844, charSequence844); + } else { + throw new RuntimeException(("Illegal union index for 'F844': "+ unionIndex844)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex845 = (decoder.readIndex()); + if (unionIndex845 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(845, null); + } else { + if (unionIndex845 == 1) { + Utf8 charSequence845; + Object oldString845 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(845); + if (oldString845 instanceof Utf8) { + charSequence845 = (decoder).readString(((Utf8) oldString845)); + } else { + charSequence845 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(845, charSequence845); + } else { + throw new RuntimeException(("Illegal union index for 'F845': "+ unionIndex845)); + } + } + int unionIndex846 = (decoder.readIndex()); + if (unionIndex846 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(846, null); + } else { + if (unionIndex846 == 1) { + Utf8 charSequence846; + Object oldString846 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(846); + if (oldString846 instanceof Utf8) { + charSequence846 = (decoder).readString(((Utf8) oldString846)); + } else { + charSequence846 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(846, charSequence846); + } else { + throw new RuntimeException(("Illegal union index for 'F846': "+ unionIndex846)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex847 = (decoder.readIndex()); + if (unionIndex847 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(847, null); + } else { + if (unionIndex847 == 1) { + Utf8 charSequence847; + Object oldString847 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(847); + if (oldString847 instanceof Utf8) { + charSequence847 = (decoder).readString(((Utf8) oldString847)); + } else { + charSequence847 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(847, charSequence847); + } else { + throw new RuntimeException(("Illegal union index for 'F847': "+ unionIndex847)); + } + } + int unionIndex848 = (decoder.readIndex()); + if (unionIndex848 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(848, null); + } else { + if (unionIndex848 == 1) { + Utf8 charSequence848; + Object oldString848 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(848); + if (oldString848 instanceof Utf8) { + charSequence848 = (decoder).readString(((Utf8) oldString848)); + } else { + charSequence848 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(848, charSequence848); + } else { + throw new RuntimeException(("Illegal union index for 'F848': "+ unionIndex848)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex849 = (decoder.readIndex()); + if (unionIndex849 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(849, null); + } else { + if (unionIndex849 == 1) { + Utf8 charSequence849; + Object oldString849 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(849); + if (oldString849 instanceof Utf8) { + charSequence849 = (decoder).readString(((Utf8) oldString849)); + } else { + charSequence849 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(849, charSequence849); + } else { + throw new RuntimeException(("Illegal union index for 'F849': "+ unionIndex849)); + } + } + int unionIndex850 = (decoder.readIndex()); + if (unionIndex850 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(850, null); + } else { + if (unionIndex850 == 1) { + Utf8 charSequence850; + Object oldString850 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(850); + if (oldString850 instanceof Utf8) { + charSequence850 = (decoder).readString(((Utf8) oldString850)); + } else { + charSequence850 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(850, charSequence850); + } else { + throw new RuntimeException(("Illegal union index for 'F850': "+ unionIndex850)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex851 = (decoder.readIndex()); + if (unionIndex851 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(851, null); + } else { + if (unionIndex851 == 1) { + Utf8 charSequence851; + Object oldString851 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(851); + if (oldString851 instanceof Utf8) { + charSequence851 = (decoder).readString(((Utf8) oldString851)); + } else { + charSequence851 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(851, charSequence851); + } else { + throw new RuntimeException(("Illegal union index for 'F851': "+ unionIndex851)); + } + } + int unionIndex852 = (decoder.readIndex()); + if (unionIndex852 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(852, null); + } else { + if (unionIndex852 == 1) { + Utf8 charSequence852; + Object oldString852 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(852); + if (oldString852 instanceof Utf8) { + charSequence852 = (decoder).readString(((Utf8) oldString852)); + } else { + charSequence852 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(852, charSequence852); + } else { + throw new RuntimeException(("Illegal union index for 'F852': "+ unionIndex852)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex853 = (decoder.readIndex()); + if (unionIndex853 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(853, null); + } else { + if (unionIndex853 == 1) { + Utf8 charSequence853; + Object oldString853 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(853); + if (oldString853 instanceof Utf8) { + charSequence853 = (decoder).readString(((Utf8) oldString853)); + } else { + charSequence853 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(853, charSequence853); + } else { + throw new RuntimeException(("Illegal union index for 'F853': "+ unionIndex853)); + } + } + int unionIndex854 = (decoder.readIndex()); + if (unionIndex854 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(854, null); + } else { + if (unionIndex854 == 1) { + Utf8 charSequence854; + Object oldString854 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(854); + if (oldString854 instanceof Utf8) { + charSequence854 = (decoder).readString(((Utf8) oldString854)); + } else { + charSequence854 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(854, charSequence854); + } else { + throw new RuntimeException(("Illegal union index for 'F854': "+ unionIndex854)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex855 = (decoder.readIndex()); + if (unionIndex855 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(855, null); + } else { + if (unionIndex855 == 1) { + Utf8 charSequence855; + Object oldString855 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(855); + if (oldString855 instanceof Utf8) { + charSequence855 = (decoder).readString(((Utf8) oldString855)); + } else { + charSequence855 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(855, charSequence855); + } else { + throw new RuntimeException(("Illegal union index for 'F855': "+ unionIndex855)); + } + } + int unionIndex856 = (decoder.readIndex()); + if (unionIndex856 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(856, null); + } else { + if (unionIndex856 == 1) { + Utf8 charSequence856; + Object oldString856 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(856); + if (oldString856 instanceof Utf8) { + charSequence856 = (decoder).readString(((Utf8) oldString856)); + } else { + charSequence856 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(856, charSequence856); + } else { + throw new RuntimeException(("Illegal union index for 'F856': "+ unionIndex856)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex857 = (decoder.readIndex()); + if (unionIndex857 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(857, null); + } else { + if (unionIndex857 == 1) { + Utf8 charSequence857; + Object oldString857 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(857); + if (oldString857 instanceof Utf8) { + charSequence857 = (decoder).readString(((Utf8) oldString857)); + } else { + charSequence857 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(857, charSequence857); + } else { + throw new RuntimeException(("Illegal union index for 'F857': "+ unionIndex857)); + } + } + int unionIndex858 = (decoder.readIndex()); + if (unionIndex858 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(858, null); + } else { + if (unionIndex858 == 1) { + Utf8 charSequence858; + Object oldString858 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(858); + if (oldString858 instanceof Utf8) { + charSequence858 = (decoder).readString(((Utf8) oldString858)); + } else { + charSequence858 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(858, charSequence858); + } else { + throw new RuntimeException(("Illegal union index for 'F858': "+ unionIndex858)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex859 = (decoder.readIndex()); + if (unionIndex859 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(859, null); + } else { + if (unionIndex859 == 1) { + Utf8 charSequence859; + Object oldString859 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(859); + if (oldString859 instanceof Utf8) { + charSequence859 = (decoder).readString(((Utf8) oldString859)); + } else { + charSequence859 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(859, charSequence859); + } else { + throw new RuntimeException(("Illegal union index for 'F859': "+ unionIndex859)); + } + } + int unionIndex860 = (decoder.readIndex()); + if (unionIndex860 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(860, null); + } else { + if (unionIndex860 == 1) { + Utf8 charSequence860; + Object oldString860 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(860); + if (oldString860 instanceof Utf8) { + charSequence860 = (decoder).readString(((Utf8) oldString860)); + } else { + charSequence860 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(860, charSequence860); + } else { + throw new RuntimeException(("Illegal union index for 'F860': "+ unionIndex860)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex861 = (decoder.readIndex()); + if (unionIndex861 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(861, null); + } else { + if (unionIndex861 == 1) { + Utf8 charSequence861; + Object oldString861 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(861); + if (oldString861 instanceof Utf8) { + charSequence861 = (decoder).readString(((Utf8) oldString861)); + } else { + charSequence861 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(861, charSequence861); + } else { + throw new RuntimeException(("Illegal union index for 'F861': "+ unionIndex861)); + } + } + int unionIndex862 = (decoder.readIndex()); + if (unionIndex862 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(862, null); + } else { + if (unionIndex862 == 1) { + Utf8 charSequence862; + Object oldString862 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(862); + if (oldString862 instanceof Utf8) { + charSequence862 = (decoder).readString(((Utf8) oldString862)); + } else { + charSequence862 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(862, charSequence862); + } else { + throw new RuntimeException(("Illegal union index for 'F862': "+ unionIndex862)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex863 = (decoder.readIndex()); + if (unionIndex863 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(863, null); + } else { + if (unionIndex863 == 1) { + Utf8 charSequence863; + Object oldString863 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(863); + if (oldString863 instanceof Utf8) { + charSequence863 = (decoder).readString(((Utf8) oldString863)); + } else { + charSequence863 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(863, charSequence863); + } else { + throw new RuntimeException(("Illegal union index for 'F863': "+ unionIndex863)); + } + } + int unionIndex864 = (decoder.readIndex()); + if (unionIndex864 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(864, null); + } else { + if (unionIndex864 == 1) { + Utf8 charSequence864; + Object oldString864 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(864); + if (oldString864 instanceof Utf8) { + charSequence864 = (decoder).readString(((Utf8) oldString864)); + } else { + charSequence864 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(864, charSequence864); + } else { + throw new RuntimeException(("Illegal union index for 'F864': "+ unionIndex864)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex865 = (decoder.readIndex()); + if (unionIndex865 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(865, null); + } else { + if (unionIndex865 == 1) { + Utf8 charSequence865; + Object oldString865 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(865); + if (oldString865 instanceof Utf8) { + charSequence865 = (decoder).readString(((Utf8) oldString865)); + } else { + charSequence865 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(865, charSequence865); + } else { + throw new RuntimeException(("Illegal union index for 'F865': "+ unionIndex865)); + } + } + int unionIndex866 = (decoder.readIndex()); + if (unionIndex866 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(866, null); + } else { + if (unionIndex866 == 1) { + Utf8 charSequence866; + Object oldString866 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(866); + if (oldString866 instanceof Utf8) { + charSequence866 = (decoder).readString(((Utf8) oldString866)); + } else { + charSequence866 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(866, charSequence866); + } else { + throw new RuntimeException(("Illegal union index for 'F866': "+ unionIndex866)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex867 = (decoder.readIndex()); + if (unionIndex867 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(867, null); + } else { + if (unionIndex867 == 1) { + Utf8 charSequence867; + Object oldString867 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(867); + if (oldString867 instanceof Utf8) { + charSequence867 = (decoder).readString(((Utf8) oldString867)); + } else { + charSequence867 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(867, charSequence867); + } else { + throw new RuntimeException(("Illegal union index for 'F867': "+ unionIndex867)); + } + } + int unionIndex868 = (decoder.readIndex()); + if (unionIndex868 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(868, null); + } else { + if (unionIndex868 == 1) { + Utf8 charSequence868; + Object oldString868 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(868); + if (oldString868 instanceof Utf8) { + charSequence868 = (decoder).readString(((Utf8) oldString868)); + } else { + charSequence868 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(868, charSequence868); + } else { + throw new RuntimeException(("Illegal union index for 'F868': "+ unionIndex868)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex869 = (decoder.readIndex()); + if (unionIndex869 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(869, null); + } else { + if (unionIndex869 == 1) { + Utf8 charSequence869; + Object oldString869 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(869); + if (oldString869 instanceof Utf8) { + charSequence869 = (decoder).readString(((Utf8) oldString869)); + } else { + charSequence869 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(869, charSequence869); + } else { + throw new RuntimeException(("Illegal union index for 'F869': "+ unionIndex869)); + } + } + int unionIndex870 = (decoder.readIndex()); + if (unionIndex870 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(870, null); + } else { + if (unionIndex870 == 1) { + Utf8 charSequence870; + Object oldString870 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(870); + if (oldString870 instanceof Utf8) { + charSequence870 = (decoder).readString(((Utf8) oldString870)); + } else { + charSequence870 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(870, charSequence870); + } else { + throw new RuntimeException(("Illegal union index for 'F870': "+ unionIndex870)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex871 = (decoder.readIndex()); + if (unionIndex871 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(871, null); + } else { + if (unionIndex871 == 1) { + Utf8 charSequence871; + Object oldString871 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(871); + if (oldString871 instanceof Utf8) { + charSequence871 = (decoder).readString(((Utf8) oldString871)); + } else { + charSequence871 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(871, charSequence871); + } else { + throw new RuntimeException(("Illegal union index for 'F871': "+ unionIndex871)); + } + } + int unionIndex872 = (decoder.readIndex()); + if (unionIndex872 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(872, null); + } else { + if (unionIndex872 == 1) { + Utf8 charSequence872; + Object oldString872 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(872); + if (oldString872 instanceof Utf8) { + charSequence872 = (decoder).readString(((Utf8) oldString872)); + } else { + charSequence872 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(872, charSequence872); + } else { + throw new RuntimeException(("Illegal union index for 'F872': "+ unionIndex872)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex873 = (decoder.readIndex()); + if (unionIndex873 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(873, null); + } else { + if (unionIndex873 == 1) { + Utf8 charSequence873; + Object oldString873 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(873); + if (oldString873 instanceof Utf8) { + charSequence873 = (decoder).readString(((Utf8) oldString873)); + } else { + charSequence873 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(873, charSequence873); + } else { + throw new RuntimeException(("Illegal union index for 'F873': "+ unionIndex873)); + } + } + int unionIndex874 = (decoder.readIndex()); + if (unionIndex874 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(874, null); + } else { + if (unionIndex874 == 1) { + Utf8 charSequence874; + Object oldString874 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(874); + if (oldString874 instanceof Utf8) { + charSequence874 = (decoder).readString(((Utf8) oldString874)); + } else { + charSequence874 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(874, charSequence874); + } else { + throw new RuntimeException(("Illegal union index for 'F874': "+ unionIndex874)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex875 = (decoder.readIndex()); + if (unionIndex875 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(875, null); + } else { + if (unionIndex875 == 1) { + Utf8 charSequence875; + Object oldString875 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(875); + if (oldString875 instanceof Utf8) { + charSequence875 = (decoder).readString(((Utf8) oldString875)); + } else { + charSequence875 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(875, charSequence875); + } else { + throw new RuntimeException(("Illegal union index for 'F875': "+ unionIndex875)); + } + } + int unionIndex876 = (decoder.readIndex()); + if (unionIndex876 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(876, null); + } else { + if (unionIndex876 == 1) { + Utf8 charSequence876; + Object oldString876 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(876); + if (oldString876 instanceof Utf8) { + charSequence876 = (decoder).readString(((Utf8) oldString876)); + } else { + charSequence876 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(876, charSequence876); + } else { + throw new RuntimeException(("Illegal union index for 'F876': "+ unionIndex876)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex877 = (decoder.readIndex()); + if (unionIndex877 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(877, null); + } else { + if (unionIndex877 == 1) { + Utf8 charSequence877; + Object oldString877 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(877); + if (oldString877 instanceof Utf8) { + charSequence877 = (decoder).readString(((Utf8) oldString877)); + } else { + charSequence877 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(877, charSequence877); + } else { + throw new RuntimeException(("Illegal union index for 'F877': "+ unionIndex877)); + } + } + int unionIndex878 = (decoder.readIndex()); + if (unionIndex878 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(878, null); + } else { + if (unionIndex878 == 1) { + Utf8 charSequence878; + Object oldString878 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(878); + if (oldString878 instanceof Utf8) { + charSequence878 = (decoder).readString(((Utf8) oldString878)); + } else { + charSequence878 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(878, charSequence878); + } else { + throw new RuntimeException(("Illegal union index for 'F878': "+ unionIndex878)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex879 = (decoder.readIndex()); + if (unionIndex879 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(879, null); + } else { + if (unionIndex879 == 1) { + Utf8 charSequence879; + Object oldString879 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(879); + if (oldString879 instanceof Utf8) { + charSequence879 = (decoder).readString(((Utf8) oldString879)); + } else { + charSequence879 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(879, charSequence879); + } else { + throw new RuntimeException(("Illegal union index for 'F879': "+ unionIndex879)); + } + } + int unionIndex880 = (decoder.readIndex()); + if (unionIndex880 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(880, null); + } else { + if (unionIndex880 == 1) { + Utf8 charSequence880; + Object oldString880 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(880); + if (oldString880 instanceof Utf8) { + charSequence880 = (decoder).readString(((Utf8) oldString880)); + } else { + charSequence880 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(880, charSequence880); + } else { + throw new RuntimeException(("Illegal union index for 'F880': "+ unionIndex880)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex881 = (decoder.readIndex()); + if (unionIndex881 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(881, null); + } else { + if (unionIndex881 == 1) { + Utf8 charSequence881; + Object oldString881 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(881); + if (oldString881 instanceof Utf8) { + charSequence881 = (decoder).readString(((Utf8) oldString881)); + } else { + charSequence881 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(881, charSequence881); + } else { + throw new RuntimeException(("Illegal union index for 'F881': "+ unionIndex881)); + } + } + int unionIndex882 = (decoder.readIndex()); + if (unionIndex882 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(882, null); + } else { + if (unionIndex882 == 1) { + Utf8 charSequence882; + Object oldString882 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(882); + if (oldString882 instanceof Utf8) { + charSequence882 = (decoder).readString(((Utf8) oldString882)); + } else { + charSequence882 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(882, charSequence882); + } else { + throw new RuntimeException(("Illegal union index for 'F882': "+ unionIndex882)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex883 = (decoder.readIndex()); + if (unionIndex883 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(883, null); + } else { + if (unionIndex883 == 1) { + Utf8 charSequence883; + Object oldString883 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(883); + if (oldString883 instanceof Utf8) { + charSequence883 = (decoder).readString(((Utf8) oldString883)); + } else { + charSequence883 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(883, charSequence883); + } else { + throw new RuntimeException(("Illegal union index for 'F883': "+ unionIndex883)); + } + } + int unionIndex884 = (decoder.readIndex()); + if (unionIndex884 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(884, null); + } else { + if (unionIndex884 == 1) { + Utf8 charSequence884; + Object oldString884 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(884); + if (oldString884 instanceof Utf8) { + charSequence884 = (decoder).readString(((Utf8) oldString884)); + } else { + charSequence884 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(884, charSequence884); + } else { + throw new RuntimeException(("Illegal union index for 'F884': "+ unionIndex884)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex885 = (decoder.readIndex()); + if (unionIndex885 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(885, null); + } else { + if (unionIndex885 == 1) { + Utf8 charSequence885; + Object oldString885 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(885); + if (oldString885 instanceof Utf8) { + charSequence885 = (decoder).readString(((Utf8) oldString885)); + } else { + charSequence885 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(885, charSequence885); + } else { + throw new RuntimeException(("Illegal union index for 'F885': "+ unionIndex885)); + } + } + int unionIndex886 = (decoder.readIndex()); + if (unionIndex886 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(886, null); + } else { + if (unionIndex886 == 1) { + Utf8 charSequence886; + Object oldString886 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(886); + if (oldString886 instanceof Utf8) { + charSequence886 = (decoder).readString(((Utf8) oldString886)); + } else { + charSequence886 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(886, charSequence886); + } else { + throw new RuntimeException(("Illegal union index for 'F886': "+ unionIndex886)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex887 = (decoder.readIndex()); + if (unionIndex887 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(887, null); + } else { + if (unionIndex887 == 1) { + Utf8 charSequence887; + Object oldString887 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(887); + if (oldString887 instanceof Utf8) { + charSequence887 = (decoder).readString(((Utf8) oldString887)); + } else { + charSequence887 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(887, charSequence887); + } else { + throw new RuntimeException(("Illegal union index for 'F887': "+ unionIndex887)); + } + } + int unionIndex888 = (decoder.readIndex()); + if (unionIndex888 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(888, null); + } else { + if (unionIndex888 == 1) { + Utf8 charSequence888; + Object oldString888 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(888); + if (oldString888 instanceof Utf8) { + charSequence888 = (decoder).readString(((Utf8) oldString888)); + } else { + charSequence888 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(888, charSequence888); + } else { + throw new RuntimeException(("Illegal union index for 'F888': "+ unionIndex888)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex889 = (decoder.readIndex()); + if (unionIndex889 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(889, null); + } else { + if (unionIndex889 == 1) { + Utf8 charSequence889; + Object oldString889 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(889); + if (oldString889 instanceof Utf8) { + charSequence889 = (decoder).readString(((Utf8) oldString889)); + } else { + charSequence889 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(889, charSequence889); + } else { + throw new RuntimeException(("Illegal union index for 'F889': "+ unionIndex889)); + } + } + int unionIndex890 = (decoder.readIndex()); + if (unionIndex890 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(890, null); + } else { + if (unionIndex890 == 1) { + Utf8 charSequence890; + Object oldString890 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(890); + if (oldString890 instanceof Utf8) { + charSequence890 = (decoder).readString(((Utf8) oldString890)); + } else { + charSequence890 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(890, charSequence890); + } else { + throw new RuntimeException(("Illegal union index for 'F890': "+ unionIndex890)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex891 = (decoder.readIndex()); + if (unionIndex891 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(891, null); + } else { + if (unionIndex891 == 1) { + Utf8 charSequence891; + Object oldString891 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(891); + if (oldString891 instanceof Utf8) { + charSequence891 = (decoder).readString(((Utf8) oldString891)); + } else { + charSequence891 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(891, charSequence891); + } else { + throw new RuntimeException(("Illegal union index for 'F891': "+ unionIndex891)); + } + } + int unionIndex892 = (decoder.readIndex()); + if (unionIndex892 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(892, null); + } else { + if (unionIndex892 == 1) { + Utf8 charSequence892; + Object oldString892 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(892); + if (oldString892 instanceof Utf8) { + charSequence892 = (decoder).readString(((Utf8) oldString892)); + } else { + charSequence892 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(892, charSequence892); + } else { + throw new RuntimeException(("Illegal union index for 'F892': "+ unionIndex892)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex893 = (decoder.readIndex()); + if (unionIndex893 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(893, null); + } else { + if (unionIndex893 == 1) { + Utf8 charSequence893; + Object oldString893 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(893); + if (oldString893 instanceof Utf8) { + charSequence893 = (decoder).readString(((Utf8) oldString893)); + } else { + charSequence893 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(893, charSequence893); + } else { + throw new RuntimeException(("Illegal union index for 'F893': "+ unionIndex893)); + } + } + int unionIndex894 = (decoder.readIndex()); + if (unionIndex894 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(894, null); + } else { + if (unionIndex894 == 1) { + Utf8 charSequence894; + Object oldString894 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(894); + if (oldString894 instanceof Utf8) { + charSequence894 = (decoder).readString(((Utf8) oldString894)); + } else { + charSequence894 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(894, charSequence894); + } else { + throw new RuntimeException(("Illegal union index for 'F894': "+ unionIndex894)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex895 = (decoder.readIndex()); + if (unionIndex895 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(895, null); + } else { + if (unionIndex895 == 1) { + Utf8 charSequence895; + Object oldString895 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(895); + if (oldString895 instanceof Utf8) { + charSequence895 = (decoder).readString(((Utf8) oldString895)); + } else { + charSequence895 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(895, charSequence895); + } else { + throw new RuntimeException(("Illegal union index for 'F895': "+ unionIndex895)); + } + } + int unionIndex896 = (decoder.readIndex()); + if (unionIndex896 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(896, null); + } else { + if (unionIndex896 == 1) { + Utf8 charSequence896; + Object oldString896 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(896); + if (oldString896 instanceof Utf8) { + charSequence896 = (decoder).readString(((Utf8) oldString896)); + } else { + charSequence896 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(896, charSequence896); + } else { + throw new RuntimeException(("Illegal union index for 'F896': "+ unionIndex896)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex897 = (decoder.readIndex()); + if (unionIndex897 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(897, null); + } else { + if (unionIndex897 == 1) { + Utf8 charSequence897; + Object oldString897 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(897); + if (oldString897 instanceof Utf8) { + charSequence897 = (decoder).readString(((Utf8) oldString897)); + } else { + charSequence897 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(897, charSequence897); + } else { + throw new RuntimeException(("Illegal union index for 'F897': "+ unionIndex897)); + } + } + int unionIndex898 = (decoder.readIndex()); + if (unionIndex898 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(898, null); + } else { + if (unionIndex898 == 1) { + Utf8 charSequence898; + Object oldString898 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(898); + if (oldString898 instanceof Utf8) { + charSequence898 = (decoder).readString(((Utf8) oldString898)); + } else { + charSequence898 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(898, charSequence898); + } else { + throw new RuntimeException(("Illegal union index for 'F898': "+ unionIndex898)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex899 = (decoder.readIndex()); + if (unionIndex899 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(899, null); + } else { + if (unionIndex899 == 1) { + Utf8 charSequence899; + Object oldString899 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(899); + if (oldString899 instanceof Utf8) { + charSequence899 = (decoder).readString(((Utf8) oldString899)); + } else { + charSequence899 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(899, charSequence899); + } else { + throw new RuntimeException(("Illegal union index for 'F899': "+ unionIndex899)); + } + } + int unionIndex900 = (decoder.readIndex()); + if (unionIndex900 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(900, null); + } else { + if (unionIndex900 == 1) { + Utf8 charSequence900; + Object oldString900 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(900); + if (oldString900 instanceof Utf8) { + charSequence900 = (decoder).readString(((Utf8) oldString900)); + } else { + charSequence900 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(900, charSequence900); + } else { + throw new RuntimeException(("Illegal union index for 'F900': "+ unionIndex900)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex901 = (decoder.readIndex()); + if (unionIndex901 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(901, null); + } else { + if (unionIndex901 == 1) { + Utf8 charSequence901; + Object oldString901 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(901); + if (oldString901 instanceof Utf8) { + charSequence901 = (decoder).readString(((Utf8) oldString901)); + } else { + charSequence901 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(901, charSequence901); + } else { + throw new RuntimeException(("Illegal union index for 'F901': "+ unionIndex901)); + } + } + int unionIndex902 = (decoder.readIndex()); + if (unionIndex902 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(902, null); + } else { + if (unionIndex902 == 1) { + Utf8 charSequence902; + Object oldString902 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(902); + if (oldString902 instanceof Utf8) { + charSequence902 = (decoder).readString(((Utf8) oldString902)); + } else { + charSequence902 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(902, charSequence902); + } else { + throw new RuntimeException(("Illegal union index for 'F902': "+ unionIndex902)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex903 = (decoder.readIndex()); + if (unionIndex903 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(903, null); + } else { + if (unionIndex903 == 1) { + Utf8 charSequence903; + Object oldString903 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(903); + if (oldString903 instanceof Utf8) { + charSequence903 = (decoder).readString(((Utf8) oldString903)); + } else { + charSequence903 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(903, charSequence903); + } else { + throw new RuntimeException(("Illegal union index for 'F903': "+ unionIndex903)); + } + } + int unionIndex904 = (decoder.readIndex()); + if (unionIndex904 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(904, null); + } else { + if (unionIndex904 == 1) { + Utf8 charSequence904; + Object oldString904 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(904); + if (oldString904 instanceof Utf8) { + charSequence904 = (decoder).readString(((Utf8) oldString904)); + } else { + charSequence904 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(904, charSequence904); + } else { + throw new RuntimeException(("Illegal union index for 'F904': "+ unionIndex904)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex905 = (decoder.readIndex()); + if (unionIndex905 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(905, null); + } else { + if (unionIndex905 == 1) { + Utf8 charSequence905; + Object oldString905 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(905); + if (oldString905 instanceof Utf8) { + charSequence905 = (decoder).readString(((Utf8) oldString905)); + } else { + charSequence905 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(905, charSequence905); + } else { + throw new RuntimeException(("Illegal union index for 'F905': "+ unionIndex905)); + } + } + int unionIndex906 = (decoder.readIndex()); + if (unionIndex906 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(906, null); + } else { + if (unionIndex906 == 1) { + Utf8 charSequence906; + Object oldString906 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(906); + if (oldString906 instanceof Utf8) { + charSequence906 = (decoder).readString(((Utf8) oldString906)); + } else { + charSequence906 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(906, charSequence906); + } else { + throw new RuntimeException(("Illegal union index for 'F906': "+ unionIndex906)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex907 = (decoder.readIndex()); + if (unionIndex907 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(907, null); + } else { + if (unionIndex907 == 1) { + Utf8 charSequence907; + Object oldString907 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(907); + if (oldString907 instanceof Utf8) { + charSequence907 = (decoder).readString(((Utf8) oldString907)); + } else { + charSequence907 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(907, charSequence907); + } else { + throw new RuntimeException(("Illegal union index for 'F907': "+ unionIndex907)); + } + } + int unionIndex908 = (decoder.readIndex()); + if (unionIndex908 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(908, null); + } else { + if (unionIndex908 == 1) { + Utf8 charSequence908; + Object oldString908 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(908); + if (oldString908 instanceof Utf8) { + charSequence908 = (decoder).readString(((Utf8) oldString908)); + } else { + charSequence908 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(908, charSequence908); + } else { + throw new RuntimeException(("Illegal union index for 'F908': "+ unionIndex908)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex909 = (decoder.readIndex()); + if (unionIndex909 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(909, null); + } else { + if (unionIndex909 == 1) { + Utf8 charSequence909; + Object oldString909 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(909); + if (oldString909 instanceof Utf8) { + charSequence909 = (decoder).readString(((Utf8) oldString909)); + } else { + charSequence909 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(909, charSequence909); + } else { + throw new RuntimeException(("Illegal union index for 'F909': "+ unionIndex909)); + } + } + int unionIndex910 = (decoder.readIndex()); + if (unionIndex910 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(910, null); + } else { + if (unionIndex910 == 1) { + Utf8 charSequence910; + Object oldString910 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(910); + if (oldString910 instanceof Utf8) { + charSequence910 = (decoder).readString(((Utf8) oldString910)); + } else { + charSequence910 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(910, charSequence910); + } else { + throw new RuntimeException(("Illegal union index for 'F910': "+ unionIndex910)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex911 = (decoder.readIndex()); + if (unionIndex911 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(911, null); + } else { + if (unionIndex911 == 1) { + Utf8 charSequence911; + Object oldString911 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(911); + if (oldString911 instanceof Utf8) { + charSequence911 = (decoder).readString(((Utf8) oldString911)); + } else { + charSequence911 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(911, charSequence911); + } else { + throw new RuntimeException(("Illegal union index for 'F911': "+ unionIndex911)); + } + } + int unionIndex912 = (decoder.readIndex()); + if (unionIndex912 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(912, null); + } else { + if (unionIndex912 == 1) { + Utf8 charSequence912; + Object oldString912 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(912); + if (oldString912 instanceof Utf8) { + charSequence912 = (decoder).readString(((Utf8) oldString912)); + } else { + charSequence912 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(912, charSequence912); + } else { + throw new RuntimeException(("Illegal union index for 'F912': "+ unionIndex912)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex913 = (decoder.readIndex()); + if (unionIndex913 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(913, null); + } else { + if (unionIndex913 == 1) { + Utf8 charSequence913; + Object oldString913 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(913); + if (oldString913 instanceof Utf8) { + charSequence913 = (decoder).readString(((Utf8) oldString913)); + } else { + charSequence913 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(913, charSequence913); + } else { + throw new RuntimeException(("Illegal union index for 'F913': "+ unionIndex913)); + } + } + int unionIndex914 = (decoder.readIndex()); + if (unionIndex914 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(914, null); + } else { + if (unionIndex914 == 1) { + Utf8 charSequence914; + Object oldString914 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(914); + if (oldString914 instanceof Utf8) { + charSequence914 = (decoder).readString(((Utf8) oldString914)); + } else { + charSequence914 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(914, charSequence914); + } else { + throw new RuntimeException(("Illegal union index for 'F914': "+ unionIndex914)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex915 = (decoder.readIndex()); + if (unionIndex915 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(915, null); + } else { + if (unionIndex915 == 1) { + Utf8 charSequence915; + Object oldString915 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(915); + if (oldString915 instanceof Utf8) { + charSequence915 = (decoder).readString(((Utf8) oldString915)); + } else { + charSequence915 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(915, charSequence915); + } else { + throw new RuntimeException(("Illegal union index for 'F915': "+ unionIndex915)); + } + } + int unionIndex916 = (decoder.readIndex()); + if (unionIndex916 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(916, null); + } else { + if (unionIndex916 == 1) { + Utf8 charSequence916; + Object oldString916 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(916); + if (oldString916 instanceof Utf8) { + charSequence916 = (decoder).readString(((Utf8) oldString916)); + } else { + charSequence916 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(916, charSequence916); + } else { + throw new RuntimeException(("Illegal union index for 'F916': "+ unionIndex916)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex917 = (decoder.readIndex()); + if (unionIndex917 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(917, null); + } else { + if (unionIndex917 == 1) { + Utf8 charSequence917; + Object oldString917 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(917); + if (oldString917 instanceof Utf8) { + charSequence917 = (decoder).readString(((Utf8) oldString917)); + } else { + charSequence917 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(917, charSequence917); + } else { + throw new RuntimeException(("Illegal union index for 'F917': "+ unionIndex917)); + } + } + int unionIndex918 = (decoder.readIndex()); + if (unionIndex918 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(918, null); + } else { + if (unionIndex918 == 1) { + Utf8 charSequence918; + Object oldString918 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(918); + if (oldString918 instanceof Utf8) { + charSequence918 = (decoder).readString(((Utf8) oldString918)); + } else { + charSequence918 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(918, charSequence918); + } else { + throw new RuntimeException(("Illegal union index for 'F918': "+ unionIndex918)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex919 = (decoder.readIndex()); + if (unionIndex919 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(919, null); + } else { + if (unionIndex919 == 1) { + Utf8 charSequence919; + Object oldString919 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(919); + if (oldString919 instanceof Utf8) { + charSequence919 = (decoder).readString(((Utf8) oldString919)); + } else { + charSequence919 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(919, charSequence919); + } else { + throw new RuntimeException(("Illegal union index for 'F919': "+ unionIndex919)); + } + } + int unionIndex920 = (decoder.readIndex()); + if (unionIndex920 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(920, null); + } else { + if (unionIndex920 == 1) { + Utf8 charSequence920; + Object oldString920 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(920); + if (oldString920 instanceof Utf8) { + charSequence920 = (decoder).readString(((Utf8) oldString920)); + } else { + charSequence920 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(920, charSequence920); + } else { + throw new RuntimeException(("Illegal union index for 'F920': "+ unionIndex920)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex921 = (decoder.readIndex()); + if (unionIndex921 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(921, null); + } else { + if (unionIndex921 == 1) { + Utf8 charSequence921; + Object oldString921 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(921); + if (oldString921 instanceof Utf8) { + charSequence921 = (decoder).readString(((Utf8) oldString921)); + } else { + charSequence921 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(921, charSequence921); + } else { + throw new RuntimeException(("Illegal union index for 'F921': "+ unionIndex921)); + } + } + int unionIndex922 = (decoder.readIndex()); + if (unionIndex922 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(922, null); + } else { + if (unionIndex922 == 1) { + Utf8 charSequence922; + Object oldString922 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(922); + if (oldString922 instanceof Utf8) { + charSequence922 = (decoder).readString(((Utf8) oldString922)); + } else { + charSequence922 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(922, charSequence922); + } else { + throw new RuntimeException(("Illegal union index for 'F922': "+ unionIndex922)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex923 = (decoder.readIndex()); + if (unionIndex923 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(923, null); + } else { + if (unionIndex923 == 1) { + Utf8 charSequence923; + Object oldString923 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(923); + if (oldString923 instanceof Utf8) { + charSequence923 = (decoder).readString(((Utf8) oldString923)); + } else { + charSequence923 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(923, charSequence923); + } else { + throw new RuntimeException(("Illegal union index for 'F923': "+ unionIndex923)); + } + } + int unionIndex924 = (decoder.readIndex()); + if (unionIndex924 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(924, null); + } else { + if (unionIndex924 == 1) { + Utf8 charSequence924; + Object oldString924 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(924); + if (oldString924 instanceof Utf8) { + charSequence924 = (decoder).readString(((Utf8) oldString924)); + } else { + charSequence924 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(924, charSequence924); + } else { + throw new RuntimeException(("Illegal union index for 'F924': "+ unionIndex924)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex925 = (decoder.readIndex()); + if (unionIndex925 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(925, null); + } else { + if (unionIndex925 == 1) { + Utf8 charSequence925; + Object oldString925 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(925); + if (oldString925 instanceof Utf8) { + charSequence925 = (decoder).readString(((Utf8) oldString925)); + } else { + charSequence925 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(925, charSequence925); + } else { + throw new RuntimeException(("Illegal union index for 'F925': "+ unionIndex925)); + } + } + int unionIndex926 = (decoder.readIndex()); + if (unionIndex926 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(926, null); + } else { + if (unionIndex926 == 1) { + Utf8 charSequence926; + Object oldString926 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(926); + if (oldString926 instanceof Utf8) { + charSequence926 = (decoder).readString(((Utf8) oldString926)); + } else { + charSequence926 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(926, charSequence926); + } else { + throw new RuntimeException(("Illegal union index for 'F926': "+ unionIndex926)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex927 = (decoder.readIndex()); + if (unionIndex927 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(927, null); + } else { + if (unionIndex927 == 1) { + Utf8 charSequence927; + Object oldString927 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(927); + if (oldString927 instanceof Utf8) { + charSequence927 = (decoder).readString(((Utf8) oldString927)); + } else { + charSequence927 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(927, charSequence927); + } else { + throw new RuntimeException(("Illegal union index for 'F927': "+ unionIndex927)); + } + } + int unionIndex928 = (decoder.readIndex()); + if (unionIndex928 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(928, null); + } else { + if (unionIndex928 == 1) { + Utf8 charSequence928; + Object oldString928 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(928); + if (oldString928 instanceof Utf8) { + charSequence928 = (decoder).readString(((Utf8) oldString928)); + } else { + charSequence928 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(928, charSequence928); + } else { + throw new RuntimeException(("Illegal union index for 'F928': "+ unionIndex928)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex929 = (decoder.readIndex()); + if (unionIndex929 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(929, null); + } else { + if (unionIndex929 == 1) { + Utf8 charSequence929; + Object oldString929 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(929); + if (oldString929 instanceof Utf8) { + charSequence929 = (decoder).readString(((Utf8) oldString929)); + } else { + charSequence929 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(929, charSequence929); + } else { + throw new RuntimeException(("Illegal union index for 'F929': "+ unionIndex929)); + } + } + int unionIndex930 = (decoder.readIndex()); + if (unionIndex930 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(930, null); + } else { + if (unionIndex930 == 1) { + Utf8 charSequence930; + Object oldString930 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(930); + if (oldString930 instanceof Utf8) { + charSequence930 = (decoder).readString(((Utf8) oldString930)); + } else { + charSequence930 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(930, charSequence930); + } else { + throw new RuntimeException(("Illegal union index for 'F930': "+ unionIndex930)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex931 = (decoder.readIndex()); + if (unionIndex931 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(931, null); + } else { + if (unionIndex931 == 1) { + Utf8 charSequence931; + Object oldString931 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(931); + if (oldString931 instanceof Utf8) { + charSequence931 = (decoder).readString(((Utf8) oldString931)); + } else { + charSequence931 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(931, charSequence931); + } else { + throw new RuntimeException(("Illegal union index for 'F931': "+ unionIndex931)); + } + } + int unionIndex932 = (decoder.readIndex()); + if (unionIndex932 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(932, null); + } else { + if (unionIndex932 == 1) { + Utf8 charSequence932; + Object oldString932 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(932); + if (oldString932 instanceof Utf8) { + charSequence932 = (decoder).readString(((Utf8) oldString932)); + } else { + charSequence932 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(932, charSequence932); + } else { + throw new RuntimeException(("Illegal union index for 'F932': "+ unionIndex932)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex933 = (decoder.readIndex()); + if (unionIndex933 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(933, null); + } else { + if (unionIndex933 == 1) { + Utf8 charSequence933; + Object oldString933 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(933); + if (oldString933 instanceof Utf8) { + charSequence933 = (decoder).readString(((Utf8) oldString933)); + } else { + charSequence933 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(933, charSequence933); + } else { + throw new RuntimeException(("Illegal union index for 'F933': "+ unionIndex933)); + } + } + int unionIndex934 = (decoder.readIndex()); + if (unionIndex934 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(934, null); + } else { + if (unionIndex934 == 1) { + Utf8 charSequence934; + Object oldString934 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(934); + if (oldString934 instanceof Utf8) { + charSequence934 = (decoder).readString(((Utf8) oldString934)); + } else { + charSequence934 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(934, charSequence934); + } else { + throw new RuntimeException(("Illegal union index for 'F934': "+ unionIndex934)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex935 = (decoder.readIndex()); + if (unionIndex935 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(935, null); + } else { + if (unionIndex935 == 1) { + Utf8 charSequence935; + Object oldString935 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(935); + if (oldString935 instanceof Utf8) { + charSequence935 = (decoder).readString(((Utf8) oldString935)); + } else { + charSequence935 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(935, charSequence935); + } else { + throw new RuntimeException(("Illegal union index for 'F935': "+ unionIndex935)); + } + } + int unionIndex936 = (decoder.readIndex()); + if (unionIndex936 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(936, null); + } else { + if (unionIndex936 == 1) { + Utf8 charSequence936; + Object oldString936 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(936); + if (oldString936 instanceof Utf8) { + charSequence936 = (decoder).readString(((Utf8) oldString936)); + } else { + charSequence936 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(936, charSequence936); + } else { + throw new RuntimeException(("Illegal union index for 'F936': "+ unionIndex936)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex937 = (decoder.readIndex()); + if (unionIndex937 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(937, null); + } else { + if (unionIndex937 == 1) { + Utf8 charSequence937; + Object oldString937 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(937); + if (oldString937 instanceof Utf8) { + charSequence937 = (decoder).readString(((Utf8) oldString937)); + } else { + charSequence937 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(937, charSequence937); + } else { + throw new RuntimeException(("Illegal union index for 'F937': "+ unionIndex937)); + } + } + int unionIndex938 = (decoder.readIndex()); + if (unionIndex938 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(938, null); + } else { + if (unionIndex938 == 1) { + Utf8 charSequence938; + Object oldString938 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(938); + if (oldString938 instanceof Utf8) { + charSequence938 = (decoder).readString(((Utf8) oldString938)); + } else { + charSequence938 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(938, charSequence938); + } else { + throw new RuntimeException(("Illegal union index for 'F938': "+ unionIndex938)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex939 = (decoder.readIndex()); + if (unionIndex939 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(939, null); + } else { + if (unionIndex939 == 1) { + Utf8 charSequence939; + Object oldString939 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(939); + if (oldString939 instanceof Utf8) { + charSequence939 = (decoder).readString(((Utf8) oldString939)); + } else { + charSequence939 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(939, charSequence939); + } else { + throw new RuntimeException(("Illegal union index for 'F939': "+ unionIndex939)); + } + } + int unionIndex940 = (decoder.readIndex()); + if (unionIndex940 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(940, null); + } else { + if (unionIndex940 == 1) { + Utf8 charSequence940; + Object oldString940 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(940); + if (oldString940 instanceof Utf8) { + charSequence940 = (decoder).readString(((Utf8) oldString940)); + } else { + charSequence940 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(940, charSequence940); + } else { + throw new RuntimeException(("Illegal union index for 'F940': "+ unionIndex940)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex941 = (decoder.readIndex()); + if (unionIndex941 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(941, null); + } else { + if (unionIndex941 == 1) { + Utf8 charSequence941; + Object oldString941 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(941); + if (oldString941 instanceof Utf8) { + charSequence941 = (decoder).readString(((Utf8) oldString941)); + } else { + charSequence941 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(941, charSequence941); + } else { + throw new RuntimeException(("Illegal union index for 'F941': "+ unionIndex941)); + } + } + int unionIndex942 = (decoder.readIndex()); + if (unionIndex942 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(942, null); + } else { + if (unionIndex942 == 1) { + Utf8 charSequence942; + Object oldString942 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(942); + if (oldString942 instanceof Utf8) { + charSequence942 = (decoder).readString(((Utf8) oldString942)); + } else { + charSequence942 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(942, charSequence942); + } else { + throw new RuntimeException(("Illegal union index for 'F942': "+ unionIndex942)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex943 = (decoder.readIndex()); + if (unionIndex943 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(943, null); + } else { + if (unionIndex943 == 1) { + Utf8 charSequence943; + Object oldString943 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(943); + if (oldString943 instanceof Utf8) { + charSequence943 = (decoder).readString(((Utf8) oldString943)); + } else { + charSequence943 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(943, charSequence943); + } else { + throw new RuntimeException(("Illegal union index for 'F943': "+ unionIndex943)); + } + } + int unionIndex944 = (decoder.readIndex()); + if (unionIndex944 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(944, null); + } else { + if (unionIndex944 == 1) { + Utf8 charSequence944; + Object oldString944 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(944); + if (oldString944 instanceof Utf8) { + charSequence944 = (decoder).readString(((Utf8) oldString944)); + } else { + charSequence944 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(944, charSequence944); + } else { + throw new RuntimeException(("Illegal union index for 'F944': "+ unionIndex944)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex945 = (decoder.readIndex()); + if (unionIndex945 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(945, null); + } else { + if (unionIndex945 == 1) { + Utf8 charSequence945; + Object oldString945 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(945); + if (oldString945 instanceof Utf8) { + charSequence945 = (decoder).readString(((Utf8) oldString945)); + } else { + charSequence945 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(945, charSequence945); + } else { + throw new RuntimeException(("Illegal union index for 'F945': "+ unionIndex945)); + } + } + int unionIndex946 = (decoder.readIndex()); + if (unionIndex946 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(946, null); + } else { + if (unionIndex946 == 1) { + Utf8 charSequence946; + Object oldString946 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(946); + if (oldString946 instanceof Utf8) { + charSequence946 = (decoder).readString(((Utf8) oldString946)); + } else { + charSequence946 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(946, charSequence946); + } else { + throw new RuntimeException(("Illegal union index for 'F946': "+ unionIndex946)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex947 = (decoder.readIndex()); + if (unionIndex947 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(947, null); + } else { + if (unionIndex947 == 1) { + Utf8 charSequence947; + Object oldString947 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(947); + if (oldString947 instanceof Utf8) { + charSequence947 = (decoder).readString(((Utf8) oldString947)); + } else { + charSequence947 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(947, charSequence947); + } else { + throw new RuntimeException(("Illegal union index for 'F947': "+ unionIndex947)); + } + } + int unionIndex948 = (decoder.readIndex()); + if (unionIndex948 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(948, null); + } else { + if (unionIndex948 == 1) { + Utf8 charSequence948; + Object oldString948 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(948); + if (oldString948 instanceof Utf8) { + charSequence948 = (decoder).readString(((Utf8) oldString948)); + } else { + charSequence948 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(948, charSequence948); + } else { + throw new RuntimeException(("Illegal union index for 'F948': "+ unionIndex948)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex949 = (decoder.readIndex()); + if (unionIndex949 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(949, null); + } else { + if (unionIndex949 == 1) { + Utf8 charSequence949; + Object oldString949 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(949); + if (oldString949 instanceof Utf8) { + charSequence949 = (decoder).readString(((Utf8) oldString949)); + } else { + charSequence949 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(949, charSequence949); + } else { + throw new RuntimeException(("Illegal union index for 'F949': "+ unionIndex949)); + } + } + int unionIndex950 = (decoder.readIndex()); + if (unionIndex950 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(950, null); + } else { + if (unionIndex950 == 1) { + Utf8 charSequence950; + Object oldString950 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(950); + if (oldString950 instanceof Utf8) { + charSequence950 = (decoder).readString(((Utf8) oldString950)); + } else { + charSequence950 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(950, charSequence950); + } else { + throw new RuntimeException(("Illegal union index for 'F950': "+ unionIndex950)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex951 = (decoder.readIndex()); + if (unionIndex951 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(951, null); + } else { + if (unionIndex951 == 1) { + Utf8 charSequence951; + Object oldString951 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(951); + if (oldString951 instanceof Utf8) { + charSequence951 = (decoder).readString(((Utf8) oldString951)); + } else { + charSequence951 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(951, charSequence951); + } else { + throw new RuntimeException(("Illegal union index for 'F951': "+ unionIndex951)); + } + } + int unionIndex952 = (decoder.readIndex()); + if (unionIndex952 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(952, null); + } else { + if (unionIndex952 == 1) { + Utf8 charSequence952; + Object oldString952 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(952); + if (oldString952 instanceof Utf8) { + charSequence952 = (decoder).readString(((Utf8) oldString952)); + } else { + charSequence952 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(952, charSequence952); + } else { + throw new RuntimeException(("Illegal union index for 'F952': "+ unionIndex952)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex953 = (decoder.readIndex()); + if (unionIndex953 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(953, null); + } else { + if (unionIndex953 == 1) { + Utf8 charSequence953; + Object oldString953 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(953); + if (oldString953 instanceof Utf8) { + charSequence953 = (decoder).readString(((Utf8) oldString953)); + } else { + charSequence953 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(953, charSequence953); + } else { + throw new RuntimeException(("Illegal union index for 'F953': "+ unionIndex953)); + } + } + int unionIndex954 = (decoder.readIndex()); + if (unionIndex954 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(954, null); + } else { + if (unionIndex954 == 1) { + Utf8 charSequence954; + Object oldString954 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(954); + if (oldString954 instanceof Utf8) { + charSequence954 = (decoder).readString(((Utf8) oldString954)); + } else { + charSequence954 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(954, charSequence954); + } else { + throw new RuntimeException(("Illegal union index for 'F954': "+ unionIndex954)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex955 = (decoder.readIndex()); + if (unionIndex955 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(955, null); + } else { + if (unionIndex955 == 1) { + Utf8 charSequence955; + Object oldString955 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(955); + if (oldString955 instanceof Utf8) { + charSequence955 = (decoder).readString(((Utf8) oldString955)); + } else { + charSequence955 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(955, charSequence955); + } else { + throw new RuntimeException(("Illegal union index for 'F955': "+ unionIndex955)); + } + } + int unionIndex956 = (decoder.readIndex()); + if (unionIndex956 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(956, null); + } else { + if (unionIndex956 == 1) { + Utf8 charSequence956; + Object oldString956 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(956); + if (oldString956 instanceof Utf8) { + charSequence956 = (decoder).readString(((Utf8) oldString956)); + } else { + charSequence956 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(956, charSequence956); + } else { + throw new RuntimeException(("Illegal union index for 'F956': "+ unionIndex956)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex957 = (decoder.readIndex()); + if (unionIndex957 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(957, null); + } else { + if (unionIndex957 == 1) { + Utf8 charSequence957; + Object oldString957 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(957); + if (oldString957 instanceof Utf8) { + charSequence957 = (decoder).readString(((Utf8) oldString957)); + } else { + charSequence957 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(957, charSequence957); + } else { + throw new RuntimeException(("Illegal union index for 'F957': "+ unionIndex957)); + } + } + int unionIndex958 = (decoder.readIndex()); + if (unionIndex958 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(958, null); + } else { + if (unionIndex958 == 1) { + Utf8 charSequence958; + Object oldString958 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(958); + if (oldString958 instanceof Utf8) { + charSequence958 = (decoder).readString(((Utf8) oldString958)); + } else { + charSequence958 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(958, charSequence958); + } else { + throw new RuntimeException(("Illegal union index for 'F958': "+ unionIndex958)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex959 = (decoder.readIndex()); + if (unionIndex959 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(959, null); + } else { + if (unionIndex959 == 1) { + Utf8 charSequence959; + Object oldString959 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(959); + if (oldString959 instanceof Utf8) { + charSequence959 = (decoder).readString(((Utf8) oldString959)); + } else { + charSequence959 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(959, charSequence959); + } else { + throw new RuntimeException(("Illegal union index for 'F959': "+ unionIndex959)); + } + } + int unionIndex960 = (decoder.readIndex()); + if (unionIndex960 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(960, null); + } else { + if (unionIndex960 == 1) { + Utf8 charSequence960; + Object oldString960 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(960); + if (oldString960 instanceof Utf8) { + charSequence960 = (decoder).readString(((Utf8) oldString960)); + } else { + charSequence960 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(960, charSequence960); + } else { + throw new RuntimeException(("Illegal union index for 'F960': "+ unionIndex960)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex961 = (decoder.readIndex()); + if (unionIndex961 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(961, null); + } else { + if (unionIndex961 == 1) { + Utf8 charSequence961; + Object oldString961 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(961); + if (oldString961 instanceof Utf8) { + charSequence961 = (decoder).readString(((Utf8) oldString961)); + } else { + charSequence961 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(961, charSequence961); + } else { + throw new RuntimeException(("Illegal union index for 'F961': "+ unionIndex961)); + } + } + int unionIndex962 = (decoder.readIndex()); + if (unionIndex962 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(962, null); + } else { + if (unionIndex962 == 1) { + Utf8 charSequence962; + Object oldString962 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(962); + if (oldString962 instanceof Utf8) { + charSequence962 = (decoder).readString(((Utf8) oldString962)); + } else { + charSequence962 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(962, charSequence962); + } else { + throw new RuntimeException(("Illegal union index for 'F962': "+ unionIndex962)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex963 = (decoder.readIndex()); + if (unionIndex963 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(963, null); + } else { + if (unionIndex963 == 1) { + Utf8 charSequence963; + Object oldString963 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(963); + if (oldString963 instanceof Utf8) { + charSequence963 = (decoder).readString(((Utf8) oldString963)); + } else { + charSequence963 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(963, charSequence963); + } else { + throw new RuntimeException(("Illegal union index for 'F963': "+ unionIndex963)); + } + } + int unionIndex964 = (decoder.readIndex()); + if (unionIndex964 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(964, null); + } else { + if (unionIndex964 == 1) { + Utf8 charSequence964; + Object oldString964 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(964); + if (oldString964 instanceof Utf8) { + charSequence964 = (decoder).readString(((Utf8) oldString964)); + } else { + charSequence964 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(964, charSequence964); + } else { + throw new RuntimeException(("Illegal union index for 'F964': "+ unionIndex964)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex965 = (decoder.readIndex()); + if (unionIndex965 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(965, null); + } else { + if (unionIndex965 == 1) { + Utf8 charSequence965; + Object oldString965 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(965); + if (oldString965 instanceof Utf8) { + charSequence965 = (decoder).readString(((Utf8) oldString965)); + } else { + charSequence965 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(965, charSequence965); + } else { + throw new RuntimeException(("Illegal union index for 'F965': "+ unionIndex965)); + } + } + int unionIndex966 = (decoder.readIndex()); + if (unionIndex966 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(966, null); + } else { + if (unionIndex966 == 1) { + Utf8 charSequence966; + Object oldString966 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(966); + if (oldString966 instanceof Utf8) { + charSequence966 = (decoder).readString(((Utf8) oldString966)); + } else { + charSequence966 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(966, charSequence966); + } else { + throw new RuntimeException(("Illegal union index for 'F966': "+ unionIndex966)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex967 = (decoder.readIndex()); + if (unionIndex967 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(967, null); + } else { + if (unionIndex967 == 1) { + Utf8 charSequence967; + Object oldString967 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(967); + if (oldString967 instanceof Utf8) { + charSequence967 = (decoder).readString(((Utf8) oldString967)); + } else { + charSequence967 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(967, charSequence967); + } else { + throw new RuntimeException(("Illegal union index for 'F967': "+ unionIndex967)); + } + } + int unionIndex968 = (decoder.readIndex()); + if (unionIndex968 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(968, null); + } else { + if (unionIndex968 == 1) { + Utf8 charSequence968; + Object oldString968 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(968); + if (oldString968 instanceof Utf8) { + charSequence968 = (decoder).readString(((Utf8) oldString968)); + } else { + charSequence968 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(968, charSequence968); + } else { + throw new RuntimeException(("Illegal union index for 'F968': "+ unionIndex968)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex969 = (decoder.readIndex()); + if (unionIndex969 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(969, null); + } else { + if (unionIndex969 == 1) { + Utf8 charSequence969; + Object oldString969 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(969); + if (oldString969 instanceof Utf8) { + charSequence969 = (decoder).readString(((Utf8) oldString969)); + } else { + charSequence969 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(969, charSequence969); + } else { + throw new RuntimeException(("Illegal union index for 'F969': "+ unionIndex969)); + } + } + int unionIndex970 = (decoder.readIndex()); + if (unionIndex970 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(970, null); + } else { + if (unionIndex970 == 1) { + Utf8 charSequence970; + Object oldString970 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(970); + if (oldString970 instanceof Utf8) { + charSequence970 = (decoder).readString(((Utf8) oldString970)); + } else { + charSequence970 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(970, charSequence970); + } else { + throw new RuntimeException(("Illegal union index for 'F970': "+ unionIndex970)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex971 = (decoder.readIndex()); + if (unionIndex971 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(971, null); + } else { + if (unionIndex971 == 1) { + Utf8 charSequence971; + Object oldString971 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(971); + if (oldString971 instanceof Utf8) { + charSequence971 = (decoder).readString(((Utf8) oldString971)); + } else { + charSequence971 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(971, charSequence971); + } else { + throw new RuntimeException(("Illegal union index for 'F971': "+ unionIndex971)); + } + } + int unionIndex972 = (decoder.readIndex()); + if (unionIndex972 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(972, null); + } else { + if (unionIndex972 == 1) { + Utf8 charSequence972; + Object oldString972 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(972); + if (oldString972 instanceof Utf8) { + charSequence972 = (decoder).readString(((Utf8) oldString972)); + } else { + charSequence972 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(972, charSequence972); + } else { + throw new RuntimeException(("Illegal union index for 'F972': "+ unionIndex972)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex973 = (decoder.readIndex()); + if (unionIndex973 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(973, null); + } else { + if (unionIndex973 == 1) { + Utf8 charSequence973; + Object oldString973 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(973); + if (oldString973 instanceof Utf8) { + charSequence973 = (decoder).readString(((Utf8) oldString973)); + } else { + charSequence973 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(973, charSequence973); + } else { + throw new RuntimeException(("Illegal union index for 'F973': "+ unionIndex973)); + } + } + int unionIndex974 = (decoder.readIndex()); + if (unionIndex974 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(974, null); + } else { + if (unionIndex974 == 1) { + Utf8 charSequence974; + Object oldString974 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(974); + if (oldString974 instanceof Utf8) { + charSequence974 = (decoder).readString(((Utf8) oldString974)); + } else { + charSequence974 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(974, charSequence974); + } else { + throw new RuntimeException(("Illegal union index for 'F974': "+ unionIndex974)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex975 = (decoder.readIndex()); + if (unionIndex975 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(975, null); + } else { + if (unionIndex975 == 1) { + Utf8 charSequence975; + Object oldString975 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(975); + if (oldString975 instanceof Utf8) { + charSequence975 = (decoder).readString(((Utf8) oldString975)); + } else { + charSequence975 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(975, charSequence975); + } else { + throw new RuntimeException(("Illegal union index for 'F975': "+ unionIndex975)); + } + } + int unionIndex976 = (decoder.readIndex()); + if (unionIndex976 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(976, null); + } else { + if (unionIndex976 == 1) { + Utf8 charSequence976; + Object oldString976 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(976); + if (oldString976 instanceof Utf8) { + charSequence976 = (decoder).readString(((Utf8) oldString976)); + } else { + charSequence976 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(976, charSequence976); + } else { + throw new RuntimeException(("Illegal union index for 'F976': "+ unionIndex976)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex977 = (decoder.readIndex()); + if (unionIndex977 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(977, null); + } else { + if (unionIndex977 == 1) { + Utf8 charSequence977; + Object oldString977 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(977); + if (oldString977 instanceof Utf8) { + charSequence977 = (decoder).readString(((Utf8) oldString977)); + } else { + charSequence977 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(977, charSequence977); + } else { + throw new RuntimeException(("Illegal union index for 'F977': "+ unionIndex977)); + } + } + int unionIndex978 = (decoder.readIndex()); + if (unionIndex978 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(978, null); + } else { + if (unionIndex978 == 1) { + Utf8 charSequence978; + Object oldString978 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(978); + if (oldString978 instanceof Utf8) { + charSequence978 = (decoder).readString(((Utf8) oldString978)); + } else { + charSequence978 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(978, charSequence978); + } else { + throw new RuntimeException(("Illegal union index for 'F978': "+ unionIndex978)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex979 = (decoder.readIndex()); + if (unionIndex979 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(979, null); + } else { + if (unionIndex979 == 1) { + Utf8 charSequence979; + Object oldString979 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(979); + if (oldString979 instanceof Utf8) { + charSequence979 = (decoder).readString(((Utf8) oldString979)); + } else { + charSequence979 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(979, charSequence979); + } else { + throw new RuntimeException(("Illegal union index for 'F979': "+ unionIndex979)); + } + } + int unionIndex980 = (decoder.readIndex()); + if (unionIndex980 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(980, null); + } else { + if (unionIndex980 == 1) { + Utf8 charSequence980; + Object oldString980 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(980); + if (oldString980 instanceof Utf8) { + charSequence980 = (decoder).readString(((Utf8) oldString980)); + } else { + charSequence980 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(980, charSequence980); + } else { + throw new RuntimeException(("Illegal union index for 'F980': "+ unionIndex980)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex981 = (decoder.readIndex()); + if (unionIndex981 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(981, null); + } else { + if (unionIndex981 == 1) { + Utf8 charSequence981; + Object oldString981 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(981); + if (oldString981 instanceof Utf8) { + charSequence981 = (decoder).readString(((Utf8) oldString981)); + } else { + charSequence981 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(981, charSequence981); + } else { + throw new RuntimeException(("Illegal union index for 'F981': "+ unionIndex981)); + } + } + int unionIndex982 = (decoder.readIndex()); + if (unionIndex982 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(982, null); + } else { + if (unionIndex982 == 1) { + Utf8 charSequence982; + Object oldString982 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(982); + if (oldString982 instanceof Utf8) { + charSequence982 = (decoder).readString(((Utf8) oldString982)); + } else { + charSequence982 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(982, charSequence982); + } else { + throw new RuntimeException(("Illegal union index for 'F982': "+ unionIndex982)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex983 = (decoder.readIndex()); + if (unionIndex983 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(983, null); + } else { + if (unionIndex983 == 1) { + Utf8 charSequence983; + Object oldString983 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(983); + if (oldString983 instanceof Utf8) { + charSequence983 = (decoder).readString(((Utf8) oldString983)); + } else { + charSequence983 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(983, charSequence983); + } else { + throw new RuntimeException(("Illegal union index for 'F983': "+ unionIndex983)); + } + } + int unionIndex984 = (decoder.readIndex()); + if (unionIndex984 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(984, null); + } else { + if (unionIndex984 == 1) { + Utf8 charSequence984; + Object oldString984 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(984); + if (oldString984 instanceof Utf8) { + charSequence984 = (decoder).readString(((Utf8) oldString984)); + } else { + charSequence984 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(984, charSequence984); + } else { + throw new RuntimeException(("Illegal union index for 'F984': "+ unionIndex984)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex985 = (decoder.readIndex()); + if (unionIndex985 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(985, null); + } else { + if (unionIndex985 == 1) { + Utf8 charSequence985; + Object oldString985 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(985); + if (oldString985 instanceof Utf8) { + charSequence985 = (decoder).readString(((Utf8) oldString985)); + } else { + charSequence985 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(985, charSequence985); + } else { + throw new RuntimeException(("Illegal union index for 'F985': "+ unionIndex985)); + } + } + int unionIndex986 = (decoder.readIndex()); + if (unionIndex986 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(986, null); + } else { + if (unionIndex986 == 1) { + Utf8 charSequence986; + Object oldString986 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(986); + if (oldString986 instanceof Utf8) { + charSequence986 = (decoder).readString(((Utf8) oldString986)); + } else { + charSequence986 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(986, charSequence986); + } else { + throw new RuntimeException(("Illegal union index for 'F986': "+ unionIndex986)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex987 = (decoder.readIndex()); + if (unionIndex987 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(987, null); + } else { + if (unionIndex987 == 1) { + Utf8 charSequence987; + Object oldString987 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(987); + if (oldString987 instanceof Utf8) { + charSequence987 = (decoder).readString(((Utf8) oldString987)); + } else { + charSequence987 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(987, charSequence987); + } else { + throw new RuntimeException(("Illegal union index for 'F987': "+ unionIndex987)); + } + } + int unionIndex988 = (decoder.readIndex()); + if (unionIndex988 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(988, null); + } else { + if (unionIndex988 == 1) { + Utf8 charSequence988; + Object oldString988 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(988); + if (oldString988 instanceof Utf8) { + charSequence988 = (decoder).readString(((Utf8) oldString988)); + } else { + charSequence988 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(988, charSequence988); + } else { + throw new RuntimeException(("Illegal union index for 'F988': "+ unionIndex988)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex989 = (decoder.readIndex()); + if (unionIndex989 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(989, null); + } else { + if (unionIndex989 == 1) { + Utf8 charSequence989; + Object oldString989 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(989); + if (oldString989 instanceof Utf8) { + charSequence989 = (decoder).readString(((Utf8) oldString989)); + } else { + charSequence989 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(989, charSequence989); + } else { + throw new RuntimeException(("Illegal union index for 'F989': "+ unionIndex989)); + } + } + int unionIndex990 = (decoder.readIndex()); + if (unionIndex990 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(990, null); + } else { + if (unionIndex990 == 1) { + Utf8 charSequence990; + Object oldString990 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(990); + if (oldString990 instanceof Utf8) { + charSequence990 = (decoder).readString(((Utf8) oldString990)); + } else { + charSequence990 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(990, charSequence990); + } else { + throw new RuntimeException(("Illegal union index for 'F990': "+ unionIndex990)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex991 = (decoder.readIndex()); + if (unionIndex991 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(991, null); + } else { + if (unionIndex991 == 1) { + Utf8 charSequence991; + Object oldString991 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(991); + if (oldString991 instanceof Utf8) { + charSequence991 = (decoder).readString(((Utf8) oldString991)); + } else { + charSequence991 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(991, charSequence991); + } else { + throw new RuntimeException(("Illegal union index for 'F991': "+ unionIndex991)); + } + } + int unionIndex992 = (decoder.readIndex()); + if (unionIndex992 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(992, null); + } else { + if (unionIndex992 == 1) { + Utf8 charSequence992; + Object oldString992 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(992); + if (oldString992 instanceof Utf8) { + charSequence992 = (decoder).readString(((Utf8) oldString992)); + } else { + charSequence992 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(992, charSequence992); + } else { + throw new RuntimeException(("Illegal union index for 'F992': "+ unionIndex992)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex993 = (decoder.readIndex()); + if (unionIndex993 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(993, null); + } else { + if (unionIndex993 == 1) { + Utf8 charSequence993; + Object oldString993 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(993); + if (oldString993 instanceof Utf8) { + charSequence993 = (decoder).readString(((Utf8) oldString993)); + } else { + charSequence993 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(993, charSequence993); + } else { + throw new RuntimeException(("Illegal union index for 'F993': "+ unionIndex993)); + } + } + int unionIndex994 = (decoder.readIndex()); + if (unionIndex994 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(994, null); + } else { + if (unionIndex994 == 1) { + Utf8 charSequence994; + Object oldString994 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(994); + if (oldString994 instanceof Utf8) { + charSequence994 = (decoder).readString(((Utf8) oldString994)); + } else { + charSequence994 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(994, charSequence994); + } else { + throw new RuntimeException(("Illegal union index for 'F994': "+ unionIndex994)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex995 = (decoder.readIndex()); + if (unionIndex995 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(995, null); + } else { + if (unionIndex995 == 1) { + Utf8 charSequence995; + Object oldString995 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(995); + if (oldString995 instanceof Utf8) { + charSequence995 = (decoder).readString(((Utf8) oldString995)); + } else { + charSequence995 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(995, charSequence995); + } else { + throw new RuntimeException(("Illegal union index for 'F995': "+ unionIndex995)); + } + } + int unionIndex996 = (decoder.readIndex()); + if (unionIndex996 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(996, null); + } else { + if (unionIndex996 == 1) { + Utf8 charSequence996; + Object oldString996 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(996); + if (oldString996 instanceof Utf8) { + charSequence996 = (decoder).readString(((Utf8) oldString996)); + } else { + charSequence996 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(996, charSequence996); + } else { + throw new RuntimeException(("Illegal union index for 'F996': "+ unionIndex996)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex997 = (decoder.readIndex()); + if (unionIndex997 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(997, null); + } else { + if (unionIndex997 == 1) { + Utf8 charSequence997; + Object oldString997 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(997); + if (oldString997 instanceof Utf8) { + charSequence997 = (decoder).readString(((Utf8) oldString997)); + } else { + charSequence997 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(997, charSequence997); + } else { + throw new RuntimeException(("Illegal union index for 'F997': "+ unionIndex997)); + } + } + int unionIndex998 = (decoder.readIndex()); + if (unionIndex998 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(998, null); + } else { + if (unionIndex998 == 1) { + Utf8 charSequence998; + Object oldString998 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(998); + if (oldString998 instanceof Utf8) { + charSequence998 = (decoder).readString(((Utf8) oldString998)); + } else { + charSequence998 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(998, charSequence998); + } else { + throw new RuntimeException(("Illegal union index for 'F998': "+ unionIndex998)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex999 = (decoder.readIndex()); + if (unionIndex999 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(999, null); + } else { + if (unionIndex999 == 1) { + Utf8 charSequence999; + Object oldString999 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(999); + if (oldString999 instanceof Utf8) { + charSequence999 = (decoder).readString(((Utf8) oldString999)); + } else { + charSequence999 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(999, charSequence999); + } else { + throw new RuntimeException(("Illegal union index for 'F999': "+ unionIndex999)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java new file mode 100644 index 000000000..6ab3b9e0b --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testString0; + private final Schema testStringUnionAlias0; + + public FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testString0 = readerSchema.getField("testString").schema(); + this.testStringUnionAlias0 = readerSchema.getField("testStringUnionAlias").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadAliasedField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadAliasedField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadAliasedField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadAliasedField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadAliasedField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldReadAliasedField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'testString': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0((FastGenericDeserializerGeneratorTest_shouldReadAliasedField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadAliasedField; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadAliasedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(1, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadAliasedField.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnionAlias': "+ unionIndex1)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java new file mode 100644 index 000000000..4ca262df9 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java @@ -0,0 +1,122 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Schema testEnumUnion0; + private final Schema testEnumArray0; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadEnum = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadEnum = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(0, new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get((decoder.readEnum())))); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum1((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(1, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(1, new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get((decoder.readEnum())))); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadEnum.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + testEnumArray1 .clear(); + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadEnum.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + testEnumUnionArray1 .clear(); + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testFixed0; + private final Schema testFixedUnion0; + private final Schema testFixedArray0; + private final Schema testFixedUnionArray0; + private final Schema testFixedUnionArrayArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadFixed_GenericDeserializer_1590965143_1590965143(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testFixed0 = readerSchema.getField("testFixed").schema(); + this.testFixedUnion0 = readerSchema.getField("testFixedUnion").schema(); + this.testFixedArray0 = readerSchema.getField("testFixedArray").schema(); + this.testFixedUnionArray0 = readerSchema.getField("testFixedUnionArray").schema(); + this.testFixedUnionArrayArrayElemSchema0 = testFixedUnionArray0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadFixed = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadFixed = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + byte[] testFixed1; + Object oldFixed0 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(0); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (2))) { + testFixed1 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed1 = ( new byte[2]); + } + decoder.readFixed(testFixed1); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(0, new org.apache.avro.generic.GenericData.Fixed(testFixed0, testFixed1)); + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed1((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadFixed; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(1, null); + } else { + if (unionIndex0 == 1) { + byte[] testFixed2; + Object oldFixed1 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(1); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (2))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[2]); + } + decoder.readFixed(testFixed2); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(1, new org.apache.avro.generic.GenericData.Fixed(testFixed0, testFixed2)); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex0)); + } + } + List testFixedArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(2); + if (oldArray0 instanceof List) { + testFixedArray1 = ((List) oldArray0); + testFixedArray1 .clear(); + } else { + testFixedArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testFixedArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(3); + if (oldArray1 instanceof List) { + testFixedUnionArray1 = ((List) oldArray1); + testFixedUnionArray1 .clear(); + } else { + testFixedUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testFixedUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema union0; + private final Schema unionOptionSchema0; + private final Schema subField0; + + public FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion_GenericDeserializer_2643982_2643982(Schema readerSchema) { + this.readerSchema = readerSchema; + this.union0 = readerSchema.getField("union").schema(); + this.unionOptionSchema0 = union0 .getTypes().get(1); + this.subField0 = unionOptionSchema0 .getField("subField").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, charSequence1); + } else { + if (unionIndex0 == 3) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + } + return FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == unionOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(unionOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java new file mode 100644 index 000000000..efcf27248 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java @@ -0,0 +1,129 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema mapField0; + private final Schema mapFieldMapValueSchema0; + private final Schema mapFieldValueMapValueSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapField0 = readerSchema.getField("mapField").schema(); + this.mapFieldMapValueSchema0 = mapField0 .getValueType(); + this.mapFieldValueMapValueSchema0 = mapFieldMapValueSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadNestedMap; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadNestedMap = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadNestedMap = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map>> mapField1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), ((int) chunkLen0))); + } else { + Map>> mapFieldReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0); + if (oldMap0 instanceof Map) { + mapFieldReuse0 = ((Map) oldMap0); + } + if (mapFieldReuse0 != (null)) { + mapFieldReuse0 .clear(); + mapField1 = mapFieldReuse0; + } else { + mapField1 = new HashMap>>(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 > mapFieldValue0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, ((int) chunkLen1))); + } else { + Map> mapFieldValueReuse0 = null; + if (null instanceof Map) { + mapFieldValueReuse0 = ((Map) null); + } + if (mapFieldValueReuse0 != (null)) { + mapFieldValueReuse0 .clear(); + mapFieldValue0 = mapFieldValueReuse0; + } else { + mapFieldValue0 = new HashMap>(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0) { + for (int counter2 = 0; (counter2 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, 0)); + } else { + mapFieldValue0 = new HashMap>(0); + } + } + mapField1 .put(key0, mapFieldValue0); + } + chunkLen0 = (decoder.mapNext()); + } while (chunkLen0 > 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), 0)); + } else { + mapField1 = new HashMap>>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadNestedMap.put(0, mapField1); + return FastGenericDeserializerGeneratorTest_shouldReadNestedMap; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java new file mode 100644 index 000000000..d79b1d246 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java @@ -0,0 +1,206 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + private final Schema testEnumUnion0; + private final Map enumMappingtestEnum1; + private final Schema testEnumArray0; + private final Map enumMappingtestEnum2; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + private final Map enumMappingtestEnum3; + + public FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(5); + tempEnumMapping0 .put(new Integer(0), new Integer(1)); + tempEnumMapping0 .put(new Integer(1), new Integer(0)); + tempEnumMapping0 .put(new Integer(2), new Integer(4)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + HashMap tempEnumMapping1 = new HashMap(5); + tempEnumMapping1 .put(new Integer(0), new Integer(1)); + tempEnumMapping1 .put(new Integer(1), new Integer(0)); + tempEnumMapping1 .put(new Integer(2), new Integer(4)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + HashMap tempEnumMapping2 = new HashMap(5); + tempEnumMapping2 .put(new Integer(0), new Integer(1)); + tempEnumMapping2 .put(new Integer(1), new Integer(0)); + tempEnumMapping2 .put(new Integer(2), new Integer(4)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + HashMap tempEnumMapping3 = new HashMap(5); + tempEnumMapping3 .put(new Integer(0), new Integer(1)); + tempEnumMapping3 .put(new Integer(1), new Integer(0)); + tempEnumMapping3 .put(new Integer(2), new Integer(4)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(0, enumValue0); + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum1((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(1, null); + } else { + if (unionIndex0 == 1) { + int enumIndex1 = (decoder.readEnum()); + GenericEnumSymbol enumValue1 = null; + Object enumIndexLookupResult1 = enumMappingtestEnum1 .get(enumIndex1); + if (enumIndexLookupResult1 instanceof Integer) { + enumValue1 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult1))); + } else { + if (enumIndexLookupResult1 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult1); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(1, enumValue1); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + testEnumArray1 .clear(); + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + testEnumUnionArray1 .clear(); + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testIntUnion0; + private final Schema testStringUnion0; + private final Schema testLongUnion0; + private final Schema testDoubleUnion0; + private final Schema testFloatUnion0; + private final Schema testBooleanUnion0; + private final Schema testBytesUnion0; + + public FastGenericDeserializerGeneratorTest_shouldReadPrimitives_GenericDeserializer_1966544736_1966544736(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testIntUnion0 = readerSchema.getField("testIntUnion").schema(); + this.testStringUnion0 = readerSchema.getField("testStringUnion").schema(); + this.testLongUnion0 = readerSchema.getField("testLongUnion").schema(); + this.testDoubleUnion0 = readerSchema.getField("testDoubleUnion").schema(); + this.testFloatUnion0 = readerSchema.getField("testFloatUnion").schema(); + this.testBooleanUnion0 = readerSchema.getField("testBooleanUnion").schema(); + this.testBytesUnion0 = readerSchema.getField("testBytesUnion").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(0, (decoder.readInt())); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPrimitives; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(1, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(2); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(2, charSequence0); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(3, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(3); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(3, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(4, (decoder.readLong())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(5, null); + } else { + if (unionIndex2 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(5, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex2)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(6, (decoder.readDouble())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(7, null); + } else { + if (unionIndex3 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(7, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex3)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(8, (decoder.readFloat())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(9, null); + } else { + if (unionIndex4 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(9, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex4)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(10, (decoder.readBoolean())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(11, null); + } else { + if (unionIndex5 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(11, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex5)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(12); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(12, byteBuffer0); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(13, null); + } else { + if (unionIndex6 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(13); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(13, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex6)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java new file mode 100644 index 000000000..764d886ab --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java @@ -0,0 +1,160 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema record10; + private final Schema subField0; + private final Schema intFieldField0; + private final Schema intField0; + private final Schema subField1; + private final Schema recordArray0; + + public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record10 = readerSchema.getField("record1").schema(); + this.subField0 = record10 .getField("subField").schema(); + this.intFieldField0 = record10 .getField("intField").schema(); + this.intField0 = record10 .getField("intField").schema(); + this.subField1 = record10 .getField("subField").schema(); + this.recordArray0 = readerSchema.getField("recordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == record10)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(record10); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + subRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(1); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(1, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex0)); + } + } + subRecord.put(0, null); + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord1(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); + List recordArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); + if (oldArray0 instanceof List) { + recordArray1 = ((List) oldArray0); + recordArray1 .clear(); + } else { + recordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema record10; + private final Schema subField0; + private final Schema record20; + private final Schema intField0; + private final Schema subField1; + private final Schema recordArray0; + + public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1365753944_1274815349(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record10 = readerSchema.getField("record1").schema(); + this.subField0 = record10 .getField("subField").schema(); + this.record20 = readerSchema.getField("record2").schema(); + this.intField0 = record20 .getField("intField").schema(); + this.subField1 = record20 .getField("subField").schema(); + this.recordArray0 = readerSchema.getField("recordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializealiasedSubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializealiasedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord aliasedSubRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == record10)) { + aliasedSubRecord = ((IndexedRecord)(reuse)); + } else { + aliasedSubRecord = new org.apache.avro.generic.GenericData.Record(record10); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + decoder.readInt(); + } else { + throw new RuntimeException(("Illegal union index for 'intField': "+ unionIndex0)); + } + } + populate_aliasedSubRecord0((aliasedSubRecord), (customization), (decoder)); + return aliasedSubRecord; + } + + private void populate_aliasedSubRecord0(IndexedRecord aliasedSubRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + aliasedSubRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = aliasedSubRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + aliasedSubRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); + List recordArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); + if (oldArray0 instanceof List) { + recordArray1 = ((List) oldArray0); + recordArray1 .clear(); + } else { + recordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema recordsArray0; + private final Schema recordsArrayArrayElemSchema0; + private final Schema subField0; + private final Schema recordsMap0; + private final Schema recordsArrayUnion0; + private final Schema recordsArrayUnionOptionSchema0; + private final Schema recordsArrayUnionOptionArrayElemSchema0; + private final Schema recordsMapUnion0; + private final Schema recordsMapUnionOptionSchema0; + private final Schema recordsMapUnionOptionMapValueSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField_GenericDeserializer_1602399407_1602399407(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordsArray0 = readerSchema.getField("recordsArray").schema(); + this.recordsArrayArrayElemSchema0 = recordsArray0 .getElementType(); + this.subField0 = recordsArrayArrayElemSchema0 .getField("subField").schema(); + this.recordsMap0 = readerSchema.getField("recordsMap").schema(); + this.recordsArrayUnion0 = readerSchema.getField("recordsArrayUnion").schema(); + this.recordsArrayUnionOptionSchema0 = recordsArrayUnion0 .getTypes().get(1); + this.recordsArrayUnionOptionArrayElemSchema0 = recordsArrayUnionOptionSchema0 .getElementType(); + this.recordsMapUnion0 = readerSchema.getField("recordsMapUnion").schema(); + this.recordsMapUnionOptionSchema0 = recordsMapUnion0 .getTypes().get(1); + this.recordsMapUnionOptionMapValueSchema0 = recordsMapUnionOptionSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List recordsArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(0); + if (oldArray0 instanceof List) { + recordsArray1 = ((List) oldArray0); + recordsArray1 .clear(); + } else { + recordsArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordsArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 recordsMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), ((int) chunkLen1))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap1 = recordsMapReuse0; + } else { + recordsMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), 0)); + } else { + recordsMap1 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(1, recordsMap1); + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(2, null); + } else { + if (unionIndex1 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(2); + if (oldArray1 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray1); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen2), recordsArrayUnionOptionSchema0); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 recordsMapUnionOption0 = null; + long chunkLen3 = (decoder.readMapStart()); + if (chunkLen3 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), ((int) chunkLen3))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); + } + } + do { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(3, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex3)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java new file mode 100644 index 000000000..478aad767 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java @@ -0,0 +1,378 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema recordsArrayMap0; + private final Schema recordsArrayMapArrayElemSchema0; + private final Schema recordsArrayMapElemMapValueSchema0; + private final Schema recordsArrayMapElemValueOptionSchema0; + private final Schema subField0; + private final Schema recordsMapArray0; + private final Schema recordsMapArrayMapValueSchema0; + private final Schema recordsMapArrayValueArrayElemSchema0; + private final Schema recordsArrayMapUnion0; + private final Schema recordsArrayMapUnionOptionArrayElemSchema0; + private final Schema recordsArrayMapUnionOptionElemMapValueSchema0; + private final Schema recordsMapArrayUnion0; + private final Schema recordsMapArrayUnionOptionSchema0; + private final Schema recordsMapArrayUnionOptionValueArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordsArrayMap0 = readerSchema.getField("recordsArrayMap").schema(); + this.recordsArrayMapArrayElemSchema0 = recordsArrayMap0 .getElementType(); + this.recordsArrayMapElemMapValueSchema0 = recordsArrayMapArrayElemSchema0 .getValueType(); + this.recordsArrayMapElemValueOptionSchema0 = recordsArrayMapElemMapValueSchema0 .getTypes().get(1); + this.subField0 = recordsArrayMapElemValueOptionSchema0 .getField("subField").schema(); + this.recordsMapArray0 = readerSchema.getField("recordsMapArray").schema(); + this.recordsMapArrayMapValueSchema0 = recordsMapArray0 .getValueType(); + this.recordsMapArrayValueArrayElemSchema0 = recordsMapArrayMapValueSchema0 .getElementType(); + this.recordsArrayMapUnion0 = readerSchema.getField("recordsArrayMapUnion").schema(); + this.recordsArrayMapUnionOptionArrayElemSchema0 = recordsArrayMap0 .getElementType(); + this.recordsArrayMapUnionOptionElemMapValueSchema0 = recordsArrayMapUnionOptionArrayElemSchema0 .getValueType(); + this.recordsMapArrayUnion0 = readerSchema.getField("recordsMapArrayUnion").schema(); + this.recordsMapArrayUnionOptionSchema0 = recordsMapArrayUnion0 .getTypes().get(1); + this.recordsMapArrayUnionOptionValueArrayElemSchema0 = recordsMapArrayMapValueSchema0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List> recordsArrayMap1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(0); + if (oldArray0 instanceof List) { + recordsArrayMap1 = ((List) oldArray0); + recordsArrayMap1 .clear(); + } else { + recordsArrayMap1 = new org.apache.avro.generic.GenericData.Array>(((int) chunkLen0), recordsArrayMap0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 recordsArrayMapElem0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen1))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap1 .add(recordsArrayMapElem0); + } + chunkLen0 = (decoder.arrayNext()); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(0, recordsArrayMap1); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordsArrayMapElemValueOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(recordsArrayMapElemValueOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray1 = null; + long chunkLen2 = (decoder.readMapStart()); + if (chunkLen2 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), ((int) chunkLen2))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap0); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray1 = recordsMapArrayReuse0; + } else { + recordsMapArray1 = new HashMap>(((int)(((chunkLen2 * 4)+ 2)/ 3))); + } + } + do { + for (int counter2 = 0; (counter2 recordsMapArrayValue0 = null; + long chunkLen3 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen3), recordsMapArrayMapValueSchema0); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), 0)); + } else { + recordsMapArray1 = new HashMap>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(1, recordsMapArray1); + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(2, null); + } else { + if (unionIndex3 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(2); + if (oldArray1 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray1); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new org.apache.avro.generic.GenericData.Array>(((int) chunkLen4), recordsArrayMap0); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArrayMapUnionOptionElem0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen5))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen4 = (decoder.arrayNext()); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(2, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex3)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(3, null); + } else { + if (unionIndex5 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), ((int) chunkLen6))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 recordsMapArrayUnionOptionValue0 = null; + long chunkLen7 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen7), recordsMapArrayMapValueSchema0); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(3, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex5)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java new file mode 100644 index 000000000..8a565e4ce --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java @@ -0,0 +1,114 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema record0; + private final Schema recordOptionSchema0; + private final Schema subField0; + private final Schema field0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record0 = readerSchema.getField("record").schema(); + this.recordOptionSchema0 = record0 .getTypes().get(1); + this.subField0 = recordOptionSchema0 .getField("subField").schema(); + this.field0 = readerSchema.getField("field").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'record': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(recordOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(1), (decoder), (customization))); + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(2, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(2); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(2, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex2)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java new file mode 100644 index 000000000..6556606e3 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java @@ -0,0 +1,252 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testNotRemoved0; + private final Schema testNotRemoved20; + private final Schema subRecord0; + private final Schema subRecordOptionSchema0; + private final Schema testNotRemoved1; + private final Schema testNotRemoved21; + private final Schema subRecordMap0; + private final Schema subRecordArray0; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testNotRemoved0 = readerSchema.getField("testNotRemoved").schema(); + this.testNotRemoved20 = readerSchema.getField("testNotRemoved2").schema(); + this.subRecord0 = readerSchema.getField("subRecord").schema(); + this.subRecordOptionSchema0 = subRecord0 .getTypes().get(1); + this.testNotRemoved1 = subRecordOptionSchema0 .getField("testNotRemoved").schema(); + this.testNotRemoved21 = subRecordOptionSchema0 .getField("testNotRemoved2").schema(); + this.subRecordMap0 = readerSchema.getField("subRecordMap").schema(); + this.subRecordArray0 = readerSchema.getField("subRecordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + } else { + if (unionIndex1 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testRemoved': "+ unionIndex1)); + } + } + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(1, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved2': "+ unionIndex2)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, null); + } else { + if (unionIndex3 == 1) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(2), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex3)); + } + } + Map subRecordMap1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), ((int) chunkLen0))); + } else { + Map subRecordMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3); + if (oldMap0 instanceof Map) { + subRecordMapReuse0 = ((Map) oldMap0); + } + if (subRecordMapReuse0 != (null)) { + subRecordMapReuse0 .clear(); + subRecordMap1 = subRecordMapReuse0; + } else { + subRecordMap1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), 0)); + } else { + subRecordMap1 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(3, subRecordMap1); + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecordOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecordOptionSchema0); + } + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex4 == 1) { + Utf8 charSequence2; + Object oldString2 = subRecord.get(0); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + subRecord.put(0, charSequence2); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex4)); + } + } + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + } else { + if (unionIndex5 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testRemoved': "+ unionIndex5)); + } + } + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + subRecord.put(1, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence3; + Object oldString3 = subRecord.get(1); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + subRecord.put(1, charSequence3); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved2': "+ unionIndex6)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List subRecordArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(4); + if (oldArray0 instanceof List) { + subRecordArray1 = ((List) oldArray0); + subRecordArray1 .clear(); + } else { + subRecordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), subRecordArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema subRecord0; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord_GenericDeserializer_1090641932_438987109(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.get(0), (decoder), (customization))); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord0); + } + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + populate_subRecord0((subRecord), (customization), (decoder)); + populate_subRecord1((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubSubRecord0(null, (decoder), (customization)); + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + deserializesubSubRecord0(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'test3': "+ unionIndex0)); + } + } + } + + public void deserializesubSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + populate_subSubRecord0((decoder)); + } + + private void populate_subSubRecord0(Decoder decoder) + throws IOException + { + decoder.skipString(); + } + + private void populate_subRecord1(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = subRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + subRecord.put(1, charSequence1); + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java new file mode 100644 index 000000000..96cd0ba88 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java @@ -0,0 +1,114 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema subRecord10; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord10 = readerSchema.getField("subRecord1").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord10)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord10); + } + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = subRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + subRecord.put(1, charSequence1); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubRecord20(null, (decoder), (customization)); + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + deserializesubRecord20(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord3': "+ unionIndex0)); + } + } + } + + public void deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + populate_subRecord20((decoder)); + } + + private void populate_subRecord20(Decoder decoder) + throws IOException + { + decoder.skipString(); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(1), (decoder), (customization))); + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java new file mode 100644 index 000000000..90bfee54d --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java @@ -0,0 +1,60 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java new file mode 100644 index 000000000..9f440e183 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java @@ -0,0 +1,60 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java new file mode 100644 index 000000000..ddebb5cb2 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + throw new AvroTypeException("Found \"long\", expecting [\"null\", \"string\"]"); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java new file mode 100644 index 000000000..7aaf38951 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java new file mode 100644 index 000000000..c423a87ce --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java new file mode 100644 index 000000000..5b68abfae --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java new file mode 100644 index 000000000..84ea4bd96 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java new file mode 100644 index 000000000..c812c8f47 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java new file mode 100644 index 000000000..863e1649d --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java @@ -0,0 +1,71 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_906204958(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_1778260273(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.put(0, null); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_906204958(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.put(0, null); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_2127585735(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + if (unionIndex0 == 1) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java new file mode 100644 index 000000000..4fc89a9f1 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + if (unionIndex0 == 1) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java new file mode 100644 index 000000000..e135cb8b8 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + if (unionIndex0 == 1) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java new file mode 100644 index 000000000..9cc529233 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + if (unionIndex0 == 1) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java new file mode 100644 index 000000000..56cd64372 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java new file mode 100644 index 000000000..ac721baa0 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java new file mode 100644 index 000000000..744a1cbd0 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java new file mode 100644 index 000000000..7940f0912 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java new file mode 100644 index 000000000..71545dffe --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + this.testOptionSchema1 = test0 .getTypes().get(2); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java new file mode 100644 index 000000000..ed12a99e4 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + this.testOptionSchema1 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java new file mode 100644 index 000000000..ca9fc3e80 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(2); + this.testOptionSchema1 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java new file mode 100644 index 000000000..419de46fa --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + this.testOptionSchema1 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java new file mode 100644 index 000000000..87e03cff5 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java @@ -0,0 +1,148 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyInReaderSchemaTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyInReaderSchemaTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence1; + Object oldString1 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + testStringArray1 .clear(); + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java new file mode 100644 index 000000000..d57c71585 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java @@ -0,0 +1,130 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyInReaderSchemaTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyInReaderSchemaTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + String charSequence0 = (decoder).readString(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, null); + } else { + if (unionIndex0 == 1) { + String charSequence1 = (decoder).readString(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + testStringArray1 .clear(); + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java new file mode 100644 index 000000000..797735242 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java @@ -0,0 +1,130 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + String charSequence0 = (decoder).readString(); + FastStringableTest_javaStringPropertyTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyTest0((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyTest1((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyTest; + } + + private void populate_FastStringableTest_javaStringPropertyTest0(IndexedRecord FastStringableTest_javaStringPropertyTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyTest.put(1, null); + } else { + if (unionIndex0 == 1) { + String charSequence1 = (decoder).readString(); + FastStringableTest_javaStringPropertyTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + testStringArray1 .clear(); + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java new file mode 100644 index 000000000..888e184a2 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java @@ -0,0 +1,1071 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex7 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex7)); + } + } + List testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema mapMapValueSchema0; + private final Schema mapValueOptionSchema0; + private final Schema field0; + + public Map_of_UNION_GenericDeserializer_2140000109_2140000109(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapValueSchema0 = readerSchema.getValueType(); + this.mapValueOptionSchema0 = mapMapValueSchema0 .getTypes().get(1); + this.field0 = mapValueOptionSchema0 .getField("field").schema(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapValueOptionSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapValueOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + record.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = record.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + record.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex1)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/Map_of_UNION_SpecificDeserializer_971650236_971650236.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/Map_of_UNION_SpecificDeserializer_971650236_971650236.java new file mode 100644 index 000000000..aea35982a --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/Map_of_UNION_SpecificDeserializer_971650236_971650236.java @@ -0,0 +1,1081 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_UNION_SpecificDeserializer_971650236_971650236 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Map_of_UNION_SpecificDeserializer_971650236_971650236(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex1)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex2)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex3)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex4)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex5 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex5)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex6 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex6)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex7 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex7)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + List testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex15 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex17)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex21 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex21)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex23 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex23)); + } + } + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex25 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex25 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex25 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex25)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema unionOptionMapValueSchema0; + + public Map_of_record_GenericDeserializer_1223705675_568621313(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOptionMapValueSchema0 = readerSchema.getValueType(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":{\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}}"); + } else { + if (unionIndex0 == 1) { + Map unionOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map unionOptionReuse0 = null; + if ((reuse) instanceof Map) { + unionOptionReuse0 = ((Map)(reuse)); + } + if (unionOptionReuse0 != (null)) { + unionOptionReuse0 .clear(); + unionOption0 = unionOptionReuse0; + } else { + unionOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + unionOption0 = new HashMap(0); + } + } + return unionOption0; + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == unionOptionMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(unionOptionMapValueSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/Map_of_record_GenericDeserializer_1677529043_1677529043.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/Map_of_record_GenericDeserializer_1677529043_1677529043.java new file mode 100644 index 000000000..3644afef8 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/Map_of_record_GenericDeserializer_1677529043_1677529043.java @@ -0,0 +1,95 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_record_GenericDeserializer_1677529043_1677529043 + implements FastDeserializer> +{ + + private final Schema readerSchema; + private final Schema mapMapValueSchema0; + private final Schema field0; + + public Map_of_record_GenericDeserializer_1677529043_1677529043(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapValueSchema0 = readerSchema.getValueType(); + this.field0 = mapMapValueSchema0 .getField("field").schema(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapMapValueSchema0); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + record.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = record.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + record.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java new file mode 100644 index 000000000..f2751d780 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java @@ -0,0 +1,61 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserialize(com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRecordWithLargeUnionField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserializeRecordWithLargeUnionField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField RecordWithLargeUnionField; + if ((reuse)!= null) { + RecordWithLargeUnionField = ((com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField)(reuse)); + } else { + RecordWithLargeUnionField = new com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Utf8 charSequence0; + Object oldString0 = RecordWithLargeUnionField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RecordWithLargeUnionField.put(0, charSequence0); + } else { + if (unionIndex0 == 1) { + RecordWithLargeUnionField.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + throw new AvroTypeException(new StringBuilder().append("Found").append(" \"byt").append("es\", ").append("expec").append("ting ").append("[\"str").append("ing\",").append(" \"int").append("\"]").toString()); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + } + return RecordWithLargeUnionField; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java new file mode 100644 index 000000000..d57959c38 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java @@ -0,0 +1,47 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; + if ((reuse)!= null) { + RemovedTypesTestRecord = ((com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord)(reuse)); + } else { + RemovedTypesTestRecord = new com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord(); + } + Utf8 charSequence0; + Object oldString0 = RemovedTypesTestRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RemovedTypesTestRecord.put(0, charSequence0); + return RemovedTypesTestRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java new file mode 100644 index 000000000..b13730dca --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java @@ -0,0 +1,406 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; + if ((reuse)!= null) { + RemovedTypesTestRecord = ((com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord)(reuse)); + } else { + RemovedTypesTestRecord = new com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord(); + } + Utf8 charSequence0; + Object oldString0 = RemovedTypesTestRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RemovedTypesTestRecord.put(0, charSequence0); + populate_RemovedTypesTestRecord0((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord1((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord2((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord3((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord4((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord5((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord6((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord7((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord8((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord9((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord10((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord11((RemovedTypesTestRecord), (customization), (decoder)); + return RemovedTypesTestRecord; + } + + private void populate_RemovedTypesTestRecord0(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.skipBytes(); + long chunkLen0 = (decoder.readArrayStart()); + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 0) { + do { + for (int counter1 = 0; (counter1 0); + } + } + + private void populate_RemovedTypesTestRecord2(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen2 = (decoder.readArrayStart()); + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 0) { + do { + for (int counter3 = 0; (counter3 0); + } + } + + private void populate_RemovedTypesTestRecord3(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.skipFixed(1); + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + } else { + if (unionIndex3 == 1) { + decoder.skipFixed(1); + } else { + throw new RuntimeException(("Illegal union index for 'removedFixedUnion': "+ unionIndex3)); + } + } + } + + private void populate_RemovedTypesTestRecord4(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen4 = (decoder.readArrayStart()); + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 0) { + do { + for (int counter5 = 0; (counter5 0); + } + } + + private void populate_RemovedTypesTestRecord5(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen6 = (decoder.readArrayStart()); + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 0) { + do { + for (int counter7 = 0; (counter7 0); + } + } + + private void populate_RemovedTypesTestRecord6(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.readEnum(); + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + } else { + if (unionIndex6 == 1) { + decoder.readEnum(); + } else { + throw new RuntimeException(("Illegal union index for 'removedEnumUnion': "+ unionIndex6)); + } + } + } + + private void populate_RemovedTypesTestRecord7(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen8 = (decoder.readArrayStart()); + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 0) { + do { + for (int counter9 = 0; (counter9 0); + } + } + + private void populate_RemovedTypesTestRecord8(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen10 = (decoder.readArrayStart()); + while (chunkLen10 > 0) { + for (int counter10 = 0; (counter10 0) { + do { + for (int counter11 = 0; (counter11 0); + } + } + + private void populate_RemovedTypesTestRecord9(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializeRemovedSubRecord0(null, (decoder), (customization)); + int unionIndex9 = (decoder.readIndex()); + if (unionIndex9 == 0) { + decoder.readNull(); + } else { + if (unionIndex9 == 1) { + deserializeRemovedSubRecord0(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'removedSubRecordUnion': "+ unionIndex9)); + } + } + } + + public void deserializeRemovedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + } + + private void populate_RemovedTypesTestRecord10(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen12 = (decoder.readArrayStart()); + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0) { + for (int counter13 = 0; (counter13 0) { + do { + for (int counter14 = 0; (counter14 0); + } + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + do { + for (int counter15 = 0; (counter15 0); + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java new file mode 100644 index 000000000..38cd2949b --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java @@ -0,0 +1,172 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class SplitRecordTest1_SpecificDeserializer_1718878379_595582209 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public SplitRecordTest1_SpecificDeserializer_1718878379_595582209(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeSplitRecordTest10((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserializeSplitRecordTest10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 SplitRecordTest1; + if ((reuse)!= null) { + SplitRecordTest1 = ((com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1)(reuse)); + } else { + SplitRecordTest1 = new com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1(); + } + SplitRecordTest1 .put(0, deserializeFullRecord0(SplitRecordTest1 .get(0), (decoder), (customization))); + populate_SplitRecordTest10((SplitRecordTest1), (customization), (decoder)); + return SplitRecordTest1; + } + + public com.linkedin.avro.fastserde.generated.avro.FullRecord deserializeFullRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.FullRecord FullRecord; + if ((reuse)!= null) { + FullRecord = ((com.linkedin.avro.fastserde.generated.avro.FullRecord)(reuse)); + } else { + FullRecord = new com.linkedin.avro.fastserde.generated.avro.FullRecord(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FullRecord.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FullRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FullRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex0)); + } + } + FullRecord.put(1, null); + return FullRecord; + } + + private void populate_SplitRecordTest10(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 SplitRecordTest1, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + SplitRecordTest1 .put(1, deserializeFullRecord1(SplitRecordTest1 .get(1), (decoder), (customization))); + List record30 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = SplitRecordTest1 .get(2); + if (oldArray0 instanceof List) { + record30 = ((List) oldArray0); + record30 .clear(); + } else { + record30 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public SplitRecordTest2_SpecificDeserializer_595582209_1718878379(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeSplitRecordTest20((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserializeSplitRecordTest20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 SplitRecordTest2; + if ((reuse)!= null) { + SplitRecordTest2 = ((com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2)(reuse)); + } else { + SplitRecordTest2 = new com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2(); + } + SplitRecordTest2 .put(0, deserializeStringRecord0(SplitRecordTest2 .get(0), (decoder), (customization))); + populate_SplitRecordTest20((SplitRecordTest2), (customization), (decoder)); + return SplitRecordTest2; + } + + public StringRecord deserializeStringRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + StringRecord IntRecord; + if ((reuse)!= null) { + IntRecord = ((StringRecord)(reuse)); + } else { + IntRecord = new StringRecord(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + IntRecord.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = IntRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + IntRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex0)); + } + } + populate_IntRecord0((IntRecord), (customization), (decoder)); + return IntRecord; + } + + private void populate_IntRecord0(StringRecord IntRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + } else { + if (unionIndex1 == 1) { + decoder.readInt(); + } else { + throw new RuntimeException(("Illegal union index for 'field2': "+ unionIndex1)); + } + } + } + + private void populate_SplitRecordTest20(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 SplitRecordTest2, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + SplitRecordTest2 .put(1, deserializeIntRecord0(SplitRecordTest2 .get(1), (decoder), (customization))); + List record30 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = SplitRecordTest2 .get(2); + if (oldArray0 instanceof List) { + record30 = ((List) oldArray0); + record30 .clear(); + } else { + record30 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public StringableRecord_SpecificDeserializer_842267318_842267318(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserialize(com.linkedin.avro.fastserde.generated.avro.StringableRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + try { + return deserializeStringableRecord0((reuse), (decoder), (customization)); + } catch (NumberFormatException e) { + throw new AvroRuntimeException(e); + } catch (MalformedURLException e) { + throw new AvroRuntimeException(e); + } catch (URISyntaxException e) { + throw new AvroRuntimeException(e); + } + } + + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserializeStringableRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord; + if ((reuse)!= null) { + StringableRecord = ((com.linkedin.avro.fastserde.generated.avro.StringableRecord)(reuse)); + } else { + StringableRecord = new com.linkedin.avro.fastserde.generated.avro.StringableRecord(); + } + Utf8 charSequence0; + Object oldString0 = StringableRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + StringableRecord.put(0, charSequence0); + populate_StringableRecord0((StringableRecord), (customization), (decoder)); + populate_StringableRecord1((StringableRecord), (customization), (decoder)); + populate_StringableRecord2((StringableRecord), (customization), (decoder)); + populate_StringableRecord3((StringableRecord), (customization), (decoder)); + populate_StringableRecord4((StringableRecord), (customization), (decoder)); + return StringableRecord; + } + + private void populate_StringableRecord0(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, URISyntaxException + { + Utf8 charSequence1; + Object oldString1 = StringableRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + StringableRecord.put(1, charSequence1); + Utf8 charSequence2; + Object oldString2 = StringableRecord.get(2); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + StringableRecord.put(2, charSequence2); + } + + private void populate_StringableRecord1(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + Utf8 charSequence3; + Object oldString3 = StringableRecord.get(3); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + StringableRecord.put(3, charSequence3); + Utf8 charSequence4; + Object oldString4 = StringableRecord.get(4); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + StringableRecord.put(4, charSequence4); + } + + private void populate_StringableRecord2(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + List urlArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = StringableRecord.get(5); + if (oldArray0 instanceof List) { + urlArray0 = ((List) oldArray0); + urlArray0 .clear(); + } else { + urlArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 urlMap0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), ((int) chunkLen1))); + } else { + Map urlMapReuse0 = null; + Object oldMap0 = StringableRecord.get(6); + if (oldMap0 instanceof Map) { + urlMapReuse0 = ((Map) oldMap0); + } + if (urlMapReuse0 != (null)) { + urlMapReuse0 .clear(); + urlMap0 = urlMapReuse0; + } else { + urlMap0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), 0)); + } else { + urlMap0 = new HashMap(0); + } + } + StringableRecord.put(6, urlMap0); + } + + private void populate_StringableRecord3(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + StringableRecord.put(7, deserializeStringableSubRecord0(StringableRecord.get(7), (decoder), (customization))); + StringableRecord.put(8, deserializeAnotherSubRecord0(StringableRecord.get(8), (decoder), (customization))); + } + + public com.linkedin.avro.fastserde.generated.avro.StringableSubRecord deserializeStringableSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException, URISyntaxException + { + com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord; + if ((reuse)!= null) { + StringableSubRecord = ((com.linkedin.avro.fastserde.generated.avro.StringableSubRecord)(reuse)); + } else { + StringableSubRecord = new com.linkedin.avro.fastserde.generated.avro.StringableSubRecord(); + } + Utf8 charSequence7; + Object oldString5 = StringableSubRecord.get(0); + if (oldString5 instanceof Utf8) { + charSequence7 = (decoder).readString(((Utf8) oldString5)); + } else { + charSequence7 = (decoder).readString(null); + } + StringableSubRecord.put(0, charSequence7); + populate_StringableSubRecord0((StringableSubRecord), (customization), (decoder)); + return StringableSubRecord; + } + + private void populate_StringableSubRecord0(com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, URISyntaxException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + StringableSubRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence8; + Object oldString6 = StringableSubRecord.get(1); + if (oldString6 instanceof Utf8) { + charSequence8 = (decoder).readString(((Utf8) oldString6)); + } else { + charSequence8 = (decoder).readString(null); + } + StringableSubRecord.put(1, charSequence8); + } else { + if (unionIndex0 == 2) { + StringableSubRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'nullStringIntUnion': "+ unionIndex0)); + } + } + } + } + + public com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord deserializeAnotherSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException, URISyntaxException + { + com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord AnotherSubRecord; + if ((reuse)!= null) { + AnotherSubRecord = ((com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord)(reuse)); + } else { + AnotherSubRecord = new com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord(); + } + AnotherSubRecord.put(0, deserializeStringableSubRecord0(AnotherSubRecord.get(0), (decoder), (customization))); + return AnotherSubRecord; + } + + private void populate_StringableRecord4(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + StringableRecord.put(9, null); + } else { + if (unionIndex1 == 1) { + String charSequence9 = (decoder).readString(); + StringableRecord.put(9, charSequence9); + } else { + throw new RuntimeException(("Illegal union index for 'stringUnion': "+ unionIndex1)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java new file mode 100644 index 000000000..146215aeb --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java @@ -0,0 +1,46 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class TestArrayOfFloats_GenericDeserializer_1408566797_1408566797 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema array_of_float0; + + public TestArrayOfFloats_GenericDeserializer_1408566797_1408566797(Schema readerSchema) { + this.readerSchema = readerSchema; + this.array_of_float0 = readerSchema.getField("array_of_float").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestArrayOfFloats0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestArrayOfFloats0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord TestArrayOfFloats; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + TestArrayOfFloats = ((IndexedRecord)(reuse)); + } else { + TestArrayOfFloats = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + PrimitiveFloatList array_of_float1 = null; + array_of_float1 = ((PrimitiveFloatList) BufferBackedPrimitiveFloatList.readPrimitiveFloatArray(TestArrayOfFloats.get(0), (decoder))); + TestArrayOfFloats.put(0, array_of_float1); + return TestArrayOfFloats; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/TestRecord_GenericDeserializer_473555078_473555078.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/TestRecord_GenericDeserializer_473555078_473555078.java new file mode 100644 index 000000000..e48c9eb5b --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/TestRecord_GenericDeserializer_473555078_473555078.java @@ -0,0 +1,78 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_GenericDeserializer_473555078_473555078 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema map_field0; + + public TestRecord_GenericDeserializer_473555078_473555078(Schema readerSchema) { + this.readerSchema = readerSchema; + this.map_field0 = readerSchema.getField("map_field").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord TestRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + TestRecord = ((IndexedRecord)(reuse)); + } else { + TestRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map map_field1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), ((int) chunkLen0))); + } else { + Map map_fieldReuse0 = null; + Object oldMap0 = TestRecord.get(0); + if (oldMap0 instanceof Map) { + map_fieldReuse0 = ((Map) oldMap0); + } + if (map_fieldReuse0 != (null)) { + map_fieldReuse0 .clear(); + map_field1 = map_fieldReuse0; + } else { + map_field1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), 0)); + } else { + map_field1 = new HashMap(0); + } + } + TestRecord.put(0, map_field1); + return TestRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/TestRecord_SpecificDeserializer_1898726132_553331077.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/TestRecord_SpecificDeserializer_1898726132_553331077.java new file mode 100644 index 000000000..4650f7ece --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/TestRecord_SpecificDeserializer_1898726132_553331077.java @@ -0,0 +1,1039 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_1898726132_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Map enumMappingTestEnum0; + private final Map enumMappingTestEnum1; + private final Map enumMappingTestEnum2; + private final Map enumMappingTestEnum3; + + public TestRecord_SpecificDeserializer_1898726132_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + HashMap tempEnumMapping0 = new HashMap(5); + tempEnumMapping0 .put(new Integer(0), new Integer(4)); + tempEnumMapping0 .put(new Integer(1), new Integer(3)); + tempEnumMapping0 .put(new Integer(2), new Integer(1)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + HashMap tempEnumMapping1 = new HashMap(5); + tempEnumMapping1 .put(new Integer(0), new Integer(4)); + tempEnumMapping1 .put(new Integer(1), new Integer(3)); + tempEnumMapping1 .put(new Integer(2), new Integer(1)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + HashMap tempEnumMapping2 = new HashMap(5); + tempEnumMapping2 .put(new Integer(0), new Integer(4)); + tempEnumMapping2 .put(new Integer(1), new Integer(3)); + tempEnumMapping2 .put(new Integer(2), new Integer(1)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + HashMap tempEnumMapping3 = new HashMap(5); + tempEnumMapping3 .put(new Integer(0), new Integer(4)); + tempEnumMapping3 .put(new Integer(1), new Integer(3)); + tempEnumMapping3 .put(new Integer(2), new Integer(1)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + ArrayList defaultArray0 = new ArrayList(); + TestRecord.put(33, defaultArray0); + ArrayList defaultArray1 = new ArrayList(); + TestRecord.put(34, defaultArray1); + ArrayList defaultArray2 = new ArrayList(); + TestRecord.put(35, defaultArray2); + ArrayList defaultArray3 = new ArrayList(); + TestRecord.put(36, defaultArray3); + ArrayList defaultArray4 = new ArrayList(); + TestRecord.put(37, defaultArray4); + ArrayList defaultArray5 = new ArrayList(); + TestRecord.put(38, defaultArray5); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + } else { + if (unionIndex7 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'removedField': "+ unionIndex7)); + } + } + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + } + + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + } + + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex16 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex18)); + } + } + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex22 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex24 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex24)); + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex26 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex26 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex26 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex26)); + } + } + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/TestRecord_SpecificDeserializer_1991094399_553331077.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/TestRecord_SpecificDeserializer_1991094399_553331077.java new file mode 100644 index 000000000..924909ded --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/TestRecord_SpecificDeserializer_1991094399_553331077.java @@ -0,0 +1,1043 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_1991094399_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Map enumMappingTestEnum0; + private final Map enumMappingTestEnum1; + private final Map enumMappingTestEnum2; + private final Map enumMappingTestEnum3; + + public TestRecord_SpecificDeserializer_1991094399_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + HashMap tempEnumMapping0 = new HashMap(6); + tempEnumMapping0 .put(new Integer(0), new Integer(4)); + tempEnumMapping0 .put(new Integer(1), new Integer(3)); + tempEnumMapping0 .put(new Integer(2), new Integer(1)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(0)); + tempEnumMapping0 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + HashMap tempEnumMapping1 = new HashMap(6); + tempEnumMapping1 .put(new Integer(0), new Integer(4)); + tempEnumMapping1 .put(new Integer(1), new Integer(3)); + tempEnumMapping1 .put(new Integer(2), new Integer(1)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(0)); + tempEnumMapping1 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + HashMap tempEnumMapping2 = new HashMap(6); + tempEnumMapping2 .put(new Integer(0), new Integer(4)); + tempEnumMapping2 .put(new Integer(1), new Integer(3)); + tempEnumMapping2 .put(new Integer(2), new Integer(1)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(0)); + tempEnumMapping2 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + HashMap tempEnumMapping3 = new HashMap(6); + tempEnumMapping3 .put(new Integer(0), new Integer(4)); + tempEnumMapping3 .put(new Integer(1), new Integer(3)); + tempEnumMapping3 .put(new Integer(2), new Integer(1)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(0)); + tempEnumMapping3 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + ArrayList defaultArray0 = new ArrayList(); + TestRecord.put(33, defaultArray0); + ArrayList defaultArray1 = new ArrayList(); + TestRecord.put(34, defaultArray1); + ArrayList defaultArray2 = new ArrayList(); + TestRecord.put(35, defaultArray2); + ArrayList defaultArray3 = new ArrayList(); + TestRecord.put(36, defaultArray3); + ArrayList defaultArray4 = new ArrayList(); + TestRecord.put(37, defaultArray4); + ArrayList defaultArray5 = new ArrayList(); + TestRecord.put(38, defaultArray5); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + } else { + if (unionIndex7 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'removedField': "+ unionIndex7)); + } + } + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + } + + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + } + + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex16 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex18)); + } + } + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex22 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex24 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex24)); + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex26 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex26 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex26 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex26)); + } + } + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/TestRecord_SpecificDeserializer_553331077_553331077.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/TestRecord_SpecificDeserializer_553331077_553331077.java new file mode 100644 index 000000000..62a970113 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/TestRecord_SpecificDeserializer_553331077_553331077.java @@ -0,0 +1,1040 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_553331077_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public TestRecord_SpecificDeserializer_553331077_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex7 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex7)); + } + } + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen16 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 stringArray0 = null; + long chunkLen20 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen20)); + } + while (chunkLen20 > 0) { + for (int counter20 = 0; (counter20 +{ + + private final Schema readerSchema; + private final Schema recordRecordSchema0; + + public UNION_GenericDeserializer_1971822364_1672473580(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordRecordSchema0 = readerSchema.getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordRecordSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(recordRecordSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/UNION_GenericDeserializer_2018567528_1606337179.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/UNION_GenericDeserializer_2018567528_1606337179.java new file mode 100644 index 000000000..ad0f8e449 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/UNION_GenericDeserializer_2018567528_1606337179.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class UNION_GenericDeserializer_2018567528_1606337179 + implements FastDeserializer> +{ + + private final Schema readerSchema; + private final Schema arrayArraySchema0; + private final Schema arrayArrayElemSchema0; + + public UNION_GenericDeserializer_2018567528_1606337179(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArraySchema0 = readerSchema.getTypes().get(1); + this.arrayArrayElemSchema0 = arrayArraySchema0 .getElementType(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), arrayArraySchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + private final Schema mapMapSchema0; + private final Schema mapMapValueSchema0; + + public UNION_GenericDeserializer_568621313_1223705675(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapSchema0 = readerSchema.getTypes().get(1); + this.mapMapValueSchema0 = mapMapSchema0 .getValueType(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapMapValueSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java new file mode 100644 index 000000000..a48705947 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.MyEnumV1; +import com.linkedin.avro.fastserde.generated.avro.MyEnumV2; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserialize(com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeUnionOfRecordsWithSameNameEnumField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserializeUnionOfRecordsWithSameNameEnumField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField UnionOfRecordsWithSameNameEnumField; + if ((reuse)!= null) { + UnionOfRecordsWithSameNameEnumField = ((com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField)(reuse)); + } else { + UnionOfRecordsWithSameNameEnumField = new com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV10(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV20(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + return UnionOfRecordsWithSameNameEnumField; + } + + public com.linkedin.avro.fastserde.generated.avro.MyRecordV1 deserializeMyRecordV10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.MyRecordV1 MyRecordV1; + if ((reuse)!= null) { + MyRecordV1 = ((com.linkedin.avro.fastserde.generated.avro.MyRecordV1)(reuse)); + } else { + MyRecordV1 = new com.linkedin.avro.fastserde.generated.avro.MyRecordV1(); + } + MyRecordV1 .put(0, Enums.getConstant(MyEnumV1 .class, (decoder.readEnum()))); + return MyRecordV1; + } + + public com.linkedin.avro.fastserde.generated.avro.MyRecordV2 deserializeMyRecordV20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.MyRecordV2 MyRecordV2; + if ((reuse)!= null) { + MyRecordV2 = ((com.linkedin.avro.fastserde.generated.avro.MyRecordV2)(reuse)); + } else { + MyRecordV2 = new com.linkedin.avro.fastserde.generated.avro.MyRecordV2(); + } + MyRecordV2 .put(0, Enums.getConstant(MyEnumV2 .class, (decoder.readEnum()))); + return MyRecordV2; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/recordName_GenericDeserializer_1743054079_1743054079.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/recordName_GenericDeserializer_1743054079_1743054079.java new file mode 100644 index 000000000..c98c109d4 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/recordName_GenericDeserializer_1743054079_1743054079.java @@ -0,0 +1,67 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class recordName_GenericDeserializer_1743054079_1743054079 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema unionField0; + + public recordName_GenericDeserializer_1743054079_1743054079(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionField0 = readerSchema.getField("unionField").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecordName0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecordName0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord recordName; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + recordName = ((IndexedRecord)(reuse)); + } else { + recordName = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = recordName.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + recordName.put(0, charSequence0); + populate_recordName0((recordName), (customization), (decoder)); + return recordName; + } + + private void populate_recordName0(IndexedRecord recordName, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + recordName.put(1, null); + } else { + if (unionIndex0 == 1) { + recordName.put(1, deserializerecordName0(recordName.get(1), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1025741720_1557256887.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1025741720_1557256887.java new file mode 100644 index 000000000..a491f24a9 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1025741720_1557256887.java @@ -0,0 +1,96 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1025741720_1557256887 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_1025741720_1557256887(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + Map someIntsOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } + } + record.put(0, someIntsOption0); + } else { + throw new RuntimeException(("Illegal union index for 'someInts': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1126840752_2099305627.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1126840752_2099305627.java new file mode 100644 index 000000000..28ea8b4b3 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1126840752_2099305627.java @@ -0,0 +1,50 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1126840752_2099305627 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1126840752_2099305627(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + record.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 1) { + throw new AvroTypeException("Found \"string\", expecting \"int\""); + } else { + throw new RuntimeException(("Illegal union index for 'someField': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1191367445_653449771.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1191367445_653449771.java new file mode 100644 index 000000000..f77f241cd --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1191367445_653449771.java @@ -0,0 +1,69 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1191367445_653449771 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_1191367445_653449771(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList someIntsOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someIntsOption0 = ((PrimitiveIntList) oldArray0); + someIntsOption0 .clear(); + } else { + someIntsOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1373882843_1971822364(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + record.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'someInt': "+ unionIndex0)); + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1556659421_711533897.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1556659421_711533897.java new file mode 100644 index 000000000..da06fa315 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1556659421_711533897.java @@ -0,0 +1,72 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1556659421_711533897 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema subRecord0; + + public record_GenericDeserializer_1556659421_711533897(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"subRecord\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"subRecord\",\"fields\":[{\"name\":\"someInt1\",\"type\":\"int\",\"doc\":\"\"},{\"name\":\"someInt2\",\"type\":\"int\",\"doc\":\"\"}]}"); + } else { + if (unionIndex0 == 1) { + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex0)); + } + } + return record; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord0); + } + subRecord.put(0, (decoder.readInt())); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + subRecord.put(1, (decoder.readInt())); + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1557256887_1025741720.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1557256887_1025741720.java new file mode 100644 index 000000000..23deeece4 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1557256887_1025741720.java @@ -0,0 +1,81 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1557256887_1025741720 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsMapSchema0; + private final Schema someIntsMapValueSchema0; + + public record_GenericDeserializer_1557256887_1025741720(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsMapSchema0 = someInts0 .getTypes().get(1); + this.someIntsMapValueSchema0 = someIntsMapSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map someInts1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } + } + record.put(0, someInts1); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1557256887_753570467.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1557256887_753570467.java new file mode 100644 index 000000000..16dc85471 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1557256887_753570467.java @@ -0,0 +1,79 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1557256887_753570467 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsMapSchema0; + + public record_GenericDeserializer_1557256887_753570467(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsMapSchema0 = someInts0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map someInts1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } + } + record.put(0, someInts1); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1672473580_1971822364.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1672473580_1971822364.java new file mode 100644 index 000000000..71be0018a --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1672473580_1971822364.java @@ -0,0 +1,50 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1672473580_1971822364 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1672473580_1971822364(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}"); + } else { + if (unionIndex0 == 1) { + return deserializerecord0((reuse), (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1971822364_1373882843.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1971822364_1373882843.java new file mode 100644 index 000000000..9bbadb740 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_1971822364_1373882843.java @@ -0,0 +1,42 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1971822364_1373882843 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInt0; + + public record_GenericDeserializer_1971822364_1373882843(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInt0 = readerSchema.getField("someInt").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_653449771_1191367445.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_653449771_1191367445.java new file mode 100644 index 000000000..dfa41cecb --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_653449771_1191367445.java @@ -0,0 +1,61 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_653449771_1191367445 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsArraySchema0; + + public record_GenericDeserializer_653449771_1191367445(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsArraySchema0 = someInts0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + PrimitiveIntList someInts1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someInts1 = ((PrimitiveIntList) oldArray0); + someInts1 .clear(); + } else { + someInts1 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsArraySchema0; + private final Schema someIntsArrayElemSchema0; + + public record_GenericDeserializer_653449771_813379571(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsArraySchema0 = someInts0 .getTypes().get(1); + this.someIntsArrayElemSchema0 = someIntsArraySchema0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List someInts1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof List) { + someInts1 = ((List) oldArray0); + someInts1 .clear(); + } else { + someInts1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), someIntsArraySchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema subRecord0; + private final Schema subRecordRecordSchema0; + + public record_GenericDeserializer_711533897_1556659421(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + this.subRecordRecordSchema0 = subRecord0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); + return record; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecordRecordSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecordRecordSchema0); + } + subRecord.put(0, (decoder.readInt())); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + subRecord.put(1, (decoder.readInt())); + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_753570467_1557256887.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_753570467_1557256887.java new file mode 100644 index 000000000..881a89956 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_753570467_1557256887.java @@ -0,0 +1,87 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_753570467_1557256887 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_753570467_1557256887(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + Map someIntsOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } + } + record.put(0, someIntsOption0); + } else { + throw new RuntimeException(("Illegal union index for 'someInts': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_813379571_653449771.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_813379571_653449771.java new file mode 100644 index 000000000..6f4a58736 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_6/record_GenericDeserializer_813379571_653449771.java @@ -0,0 +1,83 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_813379571_653449771 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_813379571_653449771(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList someIntsOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someIntsOption0 = ((PrimitiveIntList) oldArray0); + someIntsOption0 .clear(); + } else { + someIntsOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + + public testRecord_GenericDeserializer_1146484089_1256982207(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(3); + tempEnumMapping0 .put(new Integer(0), new Integer(0)); + tempEnumMapping0 .put(new Integer(1), new Integer(1)); + tempEnumMapping0 .put(new Integer(2), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.testEnum: No match for C")); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializetestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializetestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord testRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + testRecord = ((IndexedRecord)(reuse)); + } else { + testRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + testRecord.put(0, enumValue0); + return testRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/Array_of_BOOLEAN_GenericSerializer_869749973.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/Array_of_BOOLEAN_GenericSerializer_869749973.java new file mode 100644 index 000000000..5ac7ed6ef --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/Array_of_BOOLEAN_GenericSerializer_869749973.java @@ -0,0 +1,41 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.io.Encoder; + +public class Array_of_BOOLEAN_GenericSerializer_869749973 + implements FastSerializer> +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveBooleanList) { + PrimitiveBooleanList primitiveList0 = ((PrimitiveBooleanList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveDoubleList) { + PrimitiveDoubleList primitiveList0 = ((PrimitiveDoubleList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveFloatList) { + PrimitiveFloatList primitiveList0 = ((PrimitiveFloatList) array0); + if (primitiveList0 instanceof BufferBackedPrimitiveFloatList) { + BufferBackedPrimitiveFloatList bufferBackedPrimitiveFloatList = ((BufferBackedPrimitiveFloatList) primitiveList0); + bufferBackedPrimitiveFloatList.writeFloats((encoder)); + } else { + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList0 = ((PrimitiveIntList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveLongList) { + PrimitiveLongList primitiveList0 = ((PrimitiveLongList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (int counter0 = 0; (counter0 ) data).get(counter0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/Array_of_record_GenericSerializer_477614132.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/Array_of_record_GenericSerializer_477614132.java new file mode 100644 index 000000000..16cc87832 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/Array_of_record_GenericSerializer_477614132.java @@ -0,0 +1,53 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Array_of_record_GenericSerializer_477614132 + implements FastSerializer> +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (int counter0 = 0; (counter0 ) data).get(counter0); + serializeRecord0(record0, (encoder), (customization)); + } + } + (encoder).writeArrayEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java new file mode 100644 index 000000000..129e53e71 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java @@ -0,0 +1,4527 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(1))); + (encoder).writeInt(((Integer) data.get(2))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(3))); + (encoder).writeInt(((Integer) data.get(4))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(5))); + (encoder).writeInt(((Integer) data.get(6))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(7))); + (encoder).writeInt(((Integer) data.get(8))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(9))); + (encoder).writeInt(((Integer) data.get(10))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(11))); + (encoder).writeInt(((Integer) data.get(12))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(13))); + (encoder).writeInt(((Integer) data.get(14))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(15))); + (encoder).writeInt(((Integer) data.get(16))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(17))); + (encoder).writeInt(((Integer) data.get(18))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(19))); + (encoder).writeInt(((Integer) data.get(20))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(21))); + (encoder).writeInt(((Integer) data.get(22))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(23))); + (encoder).writeInt(((Integer) data.get(24))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(25))); + (encoder).writeInt(((Integer) data.get(26))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(27))); + (encoder).writeInt(((Integer) data.get(28))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(29))); + (encoder).writeInt(((Integer) data.get(30))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(31))); + (encoder).writeInt(((Integer) data.get(32))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(33))); + (encoder).writeInt(((Integer) data.get(34))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(35))); + (encoder).writeInt(((Integer) data.get(36))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(37))); + (encoder).writeInt(((Integer) data.get(38))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(39))); + (encoder).writeInt(((Integer) data.get(40))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(41))); + (encoder).writeInt(((Integer) data.get(42))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(43))); + (encoder).writeInt(((Integer) data.get(44))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(45))); + (encoder).writeInt(((Integer) data.get(46))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(47))); + (encoder).writeInt(((Integer) data.get(48))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(49))); + (encoder).writeInt(((Integer) data.get(50))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(51))); + (encoder).writeInt(((Integer) data.get(52))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(53))); + (encoder).writeInt(((Integer) data.get(54))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(55))); + (encoder).writeInt(((Integer) data.get(56))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(57))); + (encoder).writeInt(((Integer) data.get(58))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(59))); + (encoder).writeInt(((Integer) data.get(60))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(61))); + (encoder).writeInt(((Integer) data.get(62))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(63))); + (encoder).writeInt(((Integer) data.get(64))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(65))); + (encoder).writeInt(((Integer) data.get(66))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(67))); + (encoder).writeInt(((Integer) data.get(68))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(69))); + (encoder).writeInt(((Integer) data.get(70))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(71))); + (encoder).writeInt(((Integer) data.get(72))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(73))); + (encoder).writeInt(((Integer) data.get(74))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(75))); + (encoder).writeInt(((Integer) data.get(76))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(77))); + (encoder).writeInt(((Integer) data.get(78))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(79))); + (encoder).writeInt(((Integer) data.get(80))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(81))); + (encoder).writeInt(((Integer) data.get(82))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(83))); + (encoder).writeInt(((Integer) data.get(84))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(85))); + (encoder).writeInt(((Integer) data.get(86))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(87))); + (encoder).writeInt(((Integer) data.get(88))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(89))); + (encoder).writeInt(((Integer) data.get(90))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(91))); + (encoder).writeInt(((Integer) data.get(92))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(93))); + (encoder).writeInt(((Integer) data.get(94))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(95))); + (encoder).writeInt(((Integer) data.get(96))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(97))); + (encoder).writeInt(((Integer) data.get(98))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(99))); + (encoder).writeInt(((Integer) data.get(100))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(101))); + (encoder).writeInt(((Integer) data.get(102))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(103))); + (encoder).writeInt(((Integer) data.get(104))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(105))); + (encoder).writeInt(((Integer) data.get(106))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(107))); + (encoder).writeInt(((Integer) data.get(108))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(109))); + (encoder).writeInt(((Integer) data.get(110))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(111))); + (encoder).writeInt(((Integer) data.get(112))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(113))); + (encoder).writeInt(((Integer) data.get(114))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(115))); + (encoder).writeInt(((Integer) data.get(116))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(117))); + (encoder).writeInt(((Integer) data.get(118))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(119))); + (encoder).writeInt(((Integer) data.get(120))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(121))); + (encoder).writeInt(((Integer) data.get(122))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(123))); + (encoder).writeInt(((Integer) data.get(124))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(125))); + (encoder).writeInt(((Integer) data.get(126))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(127))); + (encoder).writeInt(((Integer) data.get(128))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(129))); + (encoder).writeInt(((Integer) data.get(130))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(131))); + (encoder).writeInt(((Integer) data.get(132))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(133))); + (encoder).writeInt(((Integer) data.get(134))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(135))); + (encoder).writeInt(((Integer) data.get(136))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(137))); + (encoder).writeInt(((Integer) data.get(138))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(139))); + (encoder).writeInt(((Integer) data.get(140))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(141))); + (encoder).writeInt(((Integer) data.get(142))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(143))); + (encoder).writeInt(((Integer) data.get(144))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(145))); + (encoder).writeInt(((Integer) data.get(146))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(147))); + (encoder).writeInt(((Integer) data.get(148))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(149))); + (encoder).writeInt(((Integer) data.get(150))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(151))); + (encoder).writeInt(((Integer) data.get(152))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(153))); + (encoder).writeInt(((Integer) data.get(154))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(155))); + (encoder).writeInt(((Integer) data.get(156))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(157))); + (encoder).writeInt(((Integer) data.get(158))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(159))); + (encoder).writeInt(((Integer) data.get(160))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(161))); + (encoder).writeInt(((Integer) data.get(162))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(163))); + (encoder).writeInt(((Integer) data.get(164))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(165))); + (encoder).writeInt(((Integer) data.get(166))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(167))); + (encoder).writeInt(((Integer) data.get(168))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(169))); + (encoder).writeInt(((Integer) data.get(170))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(171))); + (encoder).writeInt(((Integer) data.get(172))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(173))); + (encoder).writeInt(((Integer) data.get(174))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(175))); + (encoder).writeInt(((Integer) data.get(176))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(177))); + (encoder).writeInt(((Integer) data.get(178))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(179))); + (encoder).writeInt(((Integer) data.get(180))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(181))); + (encoder).writeInt(((Integer) data.get(182))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(183))); + (encoder).writeInt(((Integer) data.get(184))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(185))); + (encoder).writeInt(((Integer) data.get(186))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(187))); + (encoder).writeInt(((Integer) data.get(188))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(189))); + (encoder).writeInt(((Integer) data.get(190))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(191))); + (encoder).writeInt(((Integer) data.get(192))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(193))); + (encoder).writeInt(((Integer) data.get(194))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(195))); + (encoder).writeInt(((Integer) data.get(196))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(197))); + (encoder).writeInt(((Integer) data.get(198))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(199))); + (encoder).writeInt(((Integer) data.get(200))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(201))); + (encoder).writeInt(((Integer) data.get(202))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(203))); + (encoder).writeInt(((Integer) data.get(204))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(205))); + (encoder).writeInt(((Integer) data.get(206))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(207))); + (encoder).writeInt(((Integer) data.get(208))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(209))); + (encoder).writeInt(((Integer) data.get(210))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(211))); + (encoder).writeInt(((Integer) data.get(212))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(213))); + (encoder).writeInt(((Integer) data.get(214))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(215))); + (encoder).writeInt(((Integer) data.get(216))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(217))); + (encoder).writeInt(((Integer) data.get(218))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(219))); + (encoder).writeInt(((Integer) data.get(220))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(221))); + (encoder).writeInt(((Integer) data.get(222))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(223))); + (encoder).writeInt(((Integer) data.get(224))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(225))); + (encoder).writeInt(((Integer) data.get(226))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(227))); + (encoder).writeInt(((Integer) data.get(228))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(229))); + (encoder).writeInt(((Integer) data.get(230))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(231))); + (encoder).writeInt(((Integer) data.get(232))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(233))); + (encoder).writeInt(((Integer) data.get(234))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(235))); + (encoder).writeInt(((Integer) data.get(236))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(237))); + (encoder).writeInt(((Integer) data.get(238))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(239))); + (encoder).writeInt(((Integer) data.get(240))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(241))); + (encoder).writeInt(((Integer) data.get(242))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(243))); + (encoder).writeInt(((Integer) data.get(244))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(245))); + (encoder).writeInt(((Integer) data.get(246))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(247))); + (encoder).writeInt(((Integer) data.get(248))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(249))); + (encoder).writeInt(((Integer) data.get(250))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(251))); + (encoder).writeInt(((Integer) data.get(252))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(253))); + (encoder).writeInt(((Integer) data.get(254))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(255))); + (encoder).writeInt(((Integer) data.get(256))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(257))); + (encoder).writeInt(((Integer) data.get(258))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(259))); + (encoder).writeInt(((Integer) data.get(260))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(261))); + (encoder).writeInt(((Integer) data.get(262))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(263))); + (encoder).writeInt(((Integer) data.get(264))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(265))); + (encoder).writeInt(((Integer) data.get(266))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(267))); + (encoder).writeInt(((Integer) data.get(268))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(269))); + (encoder).writeInt(((Integer) data.get(270))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(271))); + (encoder).writeInt(((Integer) data.get(272))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(273))); + (encoder).writeInt(((Integer) data.get(274))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(275))); + (encoder).writeInt(((Integer) data.get(276))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(277))); + (encoder).writeInt(((Integer) data.get(278))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(279))); + (encoder).writeInt(((Integer) data.get(280))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(281))); + (encoder).writeInt(((Integer) data.get(282))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(283))); + (encoder).writeInt(((Integer) data.get(284))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(285))); + (encoder).writeInt(((Integer) data.get(286))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(287))); + (encoder).writeInt(((Integer) data.get(288))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(289))); + (encoder).writeInt(((Integer) data.get(290))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(291))); + (encoder).writeInt(((Integer) data.get(292))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(293))); + (encoder).writeInt(((Integer) data.get(294))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(295))); + (encoder).writeInt(((Integer) data.get(296))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(297))); + (encoder).writeInt(((Integer) data.get(298))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(299))); + (encoder).writeInt(((Integer) data.get(300))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(301))); + (encoder).writeInt(((Integer) data.get(302))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(303))); + (encoder).writeInt(((Integer) data.get(304))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(305))); + (encoder).writeInt(((Integer) data.get(306))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(307))); + (encoder).writeInt(((Integer) data.get(308))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(309))); + (encoder).writeInt(((Integer) data.get(310))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(311))); + (encoder).writeInt(((Integer) data.get(312))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(313))); + (encoder).writeInt(((Integer) data.get(314))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(315))); + (encoder).writeInt(((Integer) data.get(316))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(317))); + (encoder).writeInt(((Integer) data.get(318))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(319))); + (encoder).writeInt(((Integer) data.get(320))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(321))); + (encoder).writeInt(((Integer) data.get(322))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(323))); + (encoder).writeInt(((Integer) data.get(324))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(325))); + (encoder).writeInt(((Integer) data.get(326))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(327))); + (encoder).writeInt(((Integer) data.get(328))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(329))); + (encoder).writeInt(((Integer) data.get(330))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(331))); + (encoder).writeInt(((Integer) data.get(332))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(333))); + (encoder).writeInt(((Integer) data.get(334))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(335))); + (encoder).writeInt(((Integer) data.get(336))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(337))); + (encoder).writeInt(((Integer) data.get(338))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(339))); + (encoder).writeInt(((Integer) data.get(340))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(341))); + (encoder).writeInt(((Integer) data.get(342))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(343))); + (encoder).writeInt(((Integer) data.get(344))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(345))); + (encoder).writeInt(((Integer) data.get(346))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(347))); + (encoder).writeInt(((Integer) data.get(348))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(349))); + (encoder).writeInt(((Integer) data.get(350))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(351))); + (encoder).writeInt(((Integer) data.get(352))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(353))); + (encoder).writeInt(((Integer) data.get(354))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(355))); + (encoder).writeInt(((Integer) data.get(356))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(357))); + (encoder).writeInt(((Integer) data.get(358))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(359))); + (encoder).writeInt(((Integer) data.get(360))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(361))); + (encoder).writeInt(((Integer) data.get(362))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(363))); + (encoder).writeInt(((Integer) data.get(364))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(365))); + (encoder).writeInt(((Integer) data.get(366))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(367))); + (encoder).writeInt(((Integer) data.get(368))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(369))); + (encoder).writeInt(((Integer) data.get(370))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(371))); + (encoder).writeInt(((Integer) data.get(372))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(373))); + (encoder).writeInt(((Integer) data.get(374))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(375))); + (encoder).writeInt(((Integer) data.get(376))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(377))); + (encoder).writeInt(((Integer) data.get(378))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(379))); + (encoder).writeInt(((Integer) data.get(380))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(381))); + (encoder).writeInt(((Integer) data.get(382))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(383))); + (encoder).writeInt(((Integer) data.get(384))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(385))); + (encoder).writeInt(((Integer) data.get(386))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(387))); + (encoder).writeInt(((Integer) data.get(388))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(389))); + (encoder).writeInt(((Integer) data.get(390))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(391))); + (encoder).writeInt(((Integer) data.get(392))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(393))); + (encoder).writeInt(((Integer) data.get(394))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(395))); + (encoder).writeInt(((Integer) data.get(396))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(397))); + (encoder).writeInt(((Integer) data.get(398))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(399))); + (encoder).writeInt(((Integer) data.get(400))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(401))); + (encoder).writeInt(((Integer) data.get(402))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(403))); + (encoder).writeInt(((Integer) data.get(404))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(405))); + (encoder).writeInt(((Integer) data.get(406))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(407))); + (encoder).writeInt(((Integer) data.get(408))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(409))); + (encoder).writeInt(((Integer) data.get(410))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(411))); + (encoder).writeInt(((Integer) data.get(412))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(413))); + (encoder).writeInt(((Integer) data.get(414))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(415))); + (encoder).writeInt(((Integer) data.get(416))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(417))); + (encoder).writeInt(((Integer) data.get(418))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(419))); + (encoder).writeInt(((Integer) data.get(420))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(421))); + (encoder).writeInt(((Integer) data.get(422))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(423))); + (encoder).writeInt(((Integer) data.get(424))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(425))); + (encoder).writeInt(((Integer) data.get(426))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(427))); + (encoder).writeInt(((Integer) data.get(428))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(429))); + (encoder).writeInt(((Integer) data.get(430))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(431))); + (encoder).writeInt(((Integer) data.get(432))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(433))); + (encoder).writeInt(((Integer) data.get(434))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(435))); + (encoder).writeInt(((Integer) data.get(436))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(437))); + (encoder).writeInt(((Integer) data.get(438))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(439))); + (encoder).writeInt(((Integer) data.get(440))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(441))); + (encoder).writeInt(((Integer) data.get(442))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(443))); + (encoder).writeInt(((Integer) data.get(444))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(445))); + (encoder).writeInt(((Integer) data.get(446))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(447))); + (encoder).writeInt(((Integer) data.get(448))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(449))); + (encoder).writeInt(((Integer) data.get(450))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(451))); + (encoder).writeInt(((Integer) data.get(452))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(453))); + (encoder).writeInt(((Integer) data.get(454))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(455))); + (encoder).writeInt(((Integer) data.get(456))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(457))); + (encoder).writeInt(((Integer) data.get(458))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(459))); + (encoder).writeInt(((Integer) data.get(460))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(461))); + (encoder).writeInt(((Integer) data.get(462))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(463))); + (encoder).writeInt(((Integer) data.get(464))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(465))); + (encoder).writeInt(((Integer) data.get(466))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(467))); + (encoder).writeInt(((Integer) data.get(468))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(469))); + (encoder).writeInt(((Integer) data.get(470))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(471))); + (encoder).writeInt(((Integer) data.get(472))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(473))); + (encoder).writeInt(((Integer) data.get(474))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(475))); + (encoder).writeInt(((Integer) data.get(476))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(477))); + (encoder).writeInt(((Integer) data.get(478))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(479))); + (encoder).writeInt(((Integer) data.get(480))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(481))); + (encoder).writeInt(((Integer) data.get(482))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(483))); + (encoder).writeInt(((Integer) data.get(484))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(485))); + (encoder).writeInt(((Integer) data.get(486))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(487))); + (encoder).writeInt(((Integer) data.get(488))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(489))); + (encoder).writeInt(((Integer) data.get(490))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(491))); + (encoder).writeInt(((Integer) data.get(492))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(493))); + (encoder).writeInt(((Integer) data.get(494))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(495))); + (encoder).writeInt(((Integer) data.get(496))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(497))); + (encoder).writeInt(((Integer) data.get(498))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(499))); + (encoder).writeInt(((Integer) data.get(500))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(501))); + (encoder).writeInt(((Integer) data.get(502))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(503))); + (encoder).writeInt(((Integer) data.get(504))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(505))); + (encoder).writeInt(((Integer) data.get(506))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(507))); + (encoder).writeInt(((Integer) data.get(508))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(509))); + (encoder).writeInt(((Integer) data.get(510))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(511))); + (encoder).writeInt(((Integer) data.get(512))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(513))); + (encoder).writeInt(((Integer) data.get(514))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(515))); + (encoder).writeInt(((Integer) data.get(516))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(517))); + (encoder).writeInt(((Integer) data.get(518))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(519))); + (encoder).writeInt(((Integer) data.get(520))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(521))); + (encoder).writeInt(((Integer) data.get(522))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(523))); + (encoder).writeInt(((Integer) data.get(524))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(525))); + (encoder).writeInt(((Integer) data.get(526))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(527))); + (encoder).writeInt(((Integer) data.get(528))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(529))); + (encoder).writeInt(((Integer) data.get(530))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(531))); + (encoder).writeInt(((Integer) data.get(532))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(533))); + (encoder).writeInt(((Integer) data.get(534))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(535))); + (encoder).writeInt(((Integer) data.get(536))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(537))); + (encoder).writeInt(((Integer) data.get(538))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(539))); + (encoder).writeInt(((Integer) data.get(540))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(541))); + (encoder).writeInt(((Integer) data.get(542))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(543))); + (encoder).writeInt(((Integer) data.get(544))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(545))); + (encoder).writeInt(((Integer) data.get(546))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(547))); + (encoder).writeInt(((Integer) data.get(548))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(549))); + (encoder).writeInt(((Integer) data.get(550))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(551))); + (encoder).writeInt(((Integer) data.get(552))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(553))); + (encoder).writeInt(((Integer) data.get(554))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(555))); + (encoder).writeInt(((Integer) data.get(556))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(557))); + (encoder).writeInt(((Integer) data.get(558))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(559))); + (encoder).writeInt(((Integer) data.get(560))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(561))); + (encoder).writeInt(((Integer) data.get(562))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(563))); + (encoder).writeInt(((Integer) data.get(564))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(565))); + (encoder).writeInt(((Integer) data.get(566))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(567))); + (encoder).writeInt(((Integer) data.get(568))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(569))); + (encoder).writeInt(((Integer) data.get(570))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(571))); + (encoder).writeInt(((Integer) data.get(572))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(573))); + (encoder).writeInt(((Integer) data.get(574))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(575))); + (encoder).writeInt(((Integer) data.get(576))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(577))); + (encoder).writeInt(((Integer) data.get(578))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(579))); + (encoder).writeInt(((Integer) data.get(580))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(581))); + (encoder).writeInt(((Integer) data.get(582))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(583))); + (encoder).writeInt(((Integer) data.get(584))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(585))); + (encoder).writeInt(((Integer) data.get(586))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(587))); + (encoder).writeInt(((Integer) data.get(588))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(589))); + (encoder).writeInt(((Integer) data.get(590))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(591))); + (encoder).writeInt(((Integer) data.get(592))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(593))); + (encoder).writeInt(((Integer) data.get(594))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(595))); + (encoder).writeInt(((Integer) data.get(596))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(597))); + (encoder).writeInt(((Integer) data.get(598))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(599))); + (encoder).writeInt(((Integer) data.get(600))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(601))); + (encoder).writeInt(((Integer) data.get(602))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(603))); + (encoder).writeInt(((Integer) data.get(604))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(605))); + (encoder).writeInt(((Integer) data.get(606))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(607))); + (encoder).writeInt(((Integer) data.get(608))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(609))); + (encoder).writeInt(((Integer) data.get(610))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(611))); + (encoder).writeInt(((Integer) data.get(612))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(613))); + (encoder).writeInt(((Integer) data.get(614))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(615))); + (encoder).writeInt(((Integer) data.get(616))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(617))); + (encoder).writeInt(((Integer) data.get(618))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(619))); + (encoder).writeInt(((Integer) data.get(620))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(621))); + (encoder).writeInt(((Integer) data.get(622))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(623))); + (encoder).writeInt(((Integer) data.get(624))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(625))); + (encoder).writeInt(((Integer) data.get(626))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(627))); + (encoder).writeInt(((Integer) data.get(628))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(629))); + (encoder).writeInt(((Integer) data.get(630))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(631))); + (encoder).writeInt(((Integer) data.get(632))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(633))); + (encoder).writeInt(((Integer) data.get(634))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(635))); + (encoder).writeInt(((Integer) data.get(636))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(637))); + (encoder).writeInt(((Integer) data.get(638))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(639))); + (encoder).writeInt(((Integer) data.get(640))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(641))); + (encoder).writeInt(((Integer) data.get(642))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(643))); + (encoder).writeInt(((Integer) data.get(644))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(645))); + (encoder).writeInt(((Integer) data.get(646))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(647))); + (encoder).writeInt(((Integer) data.get(648))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(649))); + (encoder).writeInt(((Integer) data.get(650))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(651))); + (encoder).writeInt(((Integer) data.get(652))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(653))); + (encoder).writeInt(((Integer) data.get(654))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(655))); + (encoder).writeInt(((Integer) data.get(656))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(657))); + (encoder).writeInt(((Integer) data.get(658))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(659))); + (encoder).writeInt(((Integer) data.get(660))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(661))); + (encoder).writeInt(((Integer) data.get(662))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(663))); + (encoder).writeInt(((Integer) data.get(664))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(665))); + (encoder).writeInt(((Integer) data.get(666))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(667))); + (encoder).writeInt(((Integer) data.get(668))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(669))); + (encoder).writeInt(((Integer) data.get(670))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(671))); + (encoder).writeInt(((Integer) data.get(672))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(673))); + (encoder).writeInt(((Integer) data.get(674))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(675))); + (encoder).writeInt(((Integer) data.get(676))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(677))); + (encoder).writeInt(((Integer) data.get(678))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(679))); + (encoder).writeInt(((Integer) data.get(680))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(681))); + (encoder).writeInt(((Integer) data.get(682))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(683))); + (encoder).writeInt(((Integer) data.get(684))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(685))); + (encoder).writeInt(((Integer) data.get(686))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(687))); + (encoder).writeInt(((Integer) data.get(688))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(689))); + (encoder).writeInt(((Integer) data.get(690))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(691))); + (encoder).writeInt(((Integer) data.get(692))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(693))); + (encoder).writeInt(((Integer) data.get(694))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(695))); + (encoder).writeInt(((Integer) data.get(696))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(697))); + (encoder).writeInt(((Integer) data.get(698))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(699))); + (encoder).writeInt(((Integer) data.get(700))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(701))); + (encoder).writeInt(((Integer) data.get(702))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(703))); + (encoder).writeInt(((Integer) data.get(704))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(705))); + (encoder).writeInt(((Integer) data.get(706))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(707))); + (encoder).writeInt(((Integer) data.get(708))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(709))); + (encoder).writeInt(((Integer) data.get(710))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(711))); + (encoder).writeInt(((Integer) data.get(712))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(713))); + (encoder).writeInt(((Integer) data.get(714))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(715))); + (encoder).writeInt(((Integer) data.get(716))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(717))); + (encoder).writeInt(((Integer) data.get(718))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(719))); + (encoder).writeInt(((Integer) data.get(720))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(721))); + (encoder).writeInt(((Integer) data.get(722))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(723))); + (encoder).writeInt(((Integer) data.get(724))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(725))); + (encoder).writeInt(((Integer) data.get(726))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(727))); + (encoder).writeInt(((Integer) data.get(728))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(729))); + (encoder).writeInt(((Integer) data.get(730))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(731))); + (encoder).writeInt(((Integer) data.get(732))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(733))); + (encoder).writeInt(((Integer) data.get(734))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(735))); + (encoder).writeInt(((Integer) data.get(736))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(737))); + (encoder).writeInt(((Integer) data.get(738))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(739))); + (encoder).writeInt(((Integer) data.get(740))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(741))); + (encoder).writeInt(((Integer) data.get(742))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(743))); + (encoder).writeInt(((Integer) data.get(744))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(745))); + (encoder).writeInt(((Integer) data.get(746))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(747))); + (encoder).writeInt(((Integer) data.get(748))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(749))); + (encoder).writeInt(((Integer) data.get(750))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(751))); + (encoder).writeInt(((Integer) data.get(752))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(753))); + (encoder).writeInt(((Integer) data.get(754))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(755))); + (encoder).writeInt(((Integer) data.get(756))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(757))); + (encoder).writeInt(((Integer) data.get(758))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(759))); + (encoder).writeInt(((Integer) data.get(760))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(761))); + (encoder).writeInt(((Integer) data.get(762))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(763))); + (encoder).writeInt(((Integer) data.get(764))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(765))); + (encoder).writeInt(((Integer) data.get(766))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(767))); + (encoder).writeInt(((Integer) data.get(768))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(769))); + (encoder).writeInt(((Integer) data.get(770))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(771))); + (encoder).writeInt(((Integer) data.get(772))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(773))); + (encoder).writeInt(((Integer) data.get(774))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(775))); + (encoder).writeInt(((Integer) data.get(776))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(777))); + (encoder).writeInt(((Integer) data.get(778))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(779))); + (encoder).writeInt(((Integer) data.get(780))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(781))); + (encoder).writeInt(((Integer) data.get(782))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(783))); + (encoder).writeInt(((Integer) data.get(784))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(785))); + (encoder).writeInt(((Integer) data.get(786))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(787))); + (encoder).writeInt(((Integer) data.get(788))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(789))); + (encoder).writeInt(((Integer) data.get(790))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(791))); + (encoder).writeInt(((Integer) data.get(792))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(793))); + (encoder).writeInt(((Integer) data.get(794))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(795))); + (encoder).writeInt(((Integer) data.get(796))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(797))); + (encoder).writeInt(((Integer) data.get(798))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(799))); + (encoder).writeInt(((Integer) data.get(800))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(801))); + (encoder).writeInt(((Integer) data.get(802))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(803))); + (encoder).writeInt(((Integer) data.get(804))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(805))); + (encoder).writeInt(((Integer) data.get(806))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(807))); + (encoder).writeInt(((Integer) data.get(808))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(809))); + (encoder).writeInt(((Integer) data.get(810))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(811))); + (encoder).writeInt(((Integer) data.get(812))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(813))); + (encoder).writeInt(((Integer) data.get(814))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(815))); + (encoder).writeInt(((Integer) data.get(816))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(817))); + (encoder).writeInt(((Integer) data.get(818))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(819))); + (encoder).writeInt(((Integer) data.get(820))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(821))); + (encoder).writeInt(((Integer) data.get(822))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(823))); + (encoder).writeInt(((Integer) data.get(824))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(825))); + (encoder).writeInt(((Integer) data.get(826))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(827))); + (encoder).writeInt(((Integer) data.get(828))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(829))); + (encoder).writeInt(((Integer) data.get(830))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(831))); + (encoder).writeInt(((Integer) data.get(832))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(833))); + (encoder).writeInt(((Integer) data.get(834))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(835))); + (encoder).writeInt(((Integer) data.get(836))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(837))); + (encoder).writeInt(((Integer) data.get(838))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(839))); + (encoder).writeInt(((Integer) data.get(840))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(841))); + (encoder).writeInt(((Integer) data.get(842))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(843))); + (encoder).writeInt(((Integer) data.get(844))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(845))); + (encoder).writeInt(((Integer) data.get(846))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(847))); + (encoder).writeInt(((Integer) data.get(848))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(849))); + (encoder).writeInt(((Integer) data.get(850))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(851))); + (encoder).writeInt(((Integer) data.get(852))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(853))); + (encoder).writeInt(((Integer) data.get(854))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(855))); + (encoder).writeInt(((Integer) data.get(856))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(857))); + (encoder).writeInt(((Integer) data.get(858))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(859))); + (encoder).writeInt(((Integer) data.get(860))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(861))); + (encoder).writeInt(((Integer) data.get(862))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(863))); + (encoder).writeInt(((Integer) data.get(864))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(865))); + (encoder).writeInt(((Integer) data.get(866))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(867))); + (encoder).writeInt(((Integer) data.get(868))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(869))); + (encoder).writeInt(((Integer) data.get(870))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(871))); + (encoder).writeInt(((Integer) data.get(872))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(873))); + (encoder).writeInt(((Integer) data.get(874))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(875))); + (encoder).writeInt(((Integer) data.get(876))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(877))); + (encoder).writeInt(((Integer) data.get(878))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(879))); + (encoder).writeInt(((Integer) data.get(880))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(881))); + (encoder).writeInt(((Integer) data.get(882))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(883))); + (encoder).writeInt(((Integer) data.get(884))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(885))); + (encoder).writeInt(((Integer) data.get(886))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(887))); + (encoder).writeInt(((Integer) data.get(888))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(889))); + (encoder).writeInt(((Integer) data.get(890))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(891))); + (encoder).writeInt(((Integer) data.get(892))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(893))); + (encoder).writeInt(((Integer) data.get(894))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(895))); + (encoder).writeInt(((Integer) data.get(896))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(897))); + (encoder).writeInt(((Integer) data.get(898))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(899))); + (encoder).writeInt(((Integer) data.get(900))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(901))); + (encoder).writeInt(((Integer) data.get(902))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(903))); + (encoder).writeInt(((Integer) data.get(904))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(905))); + (encoder).writeInt(((Integer) data.get(906))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(907))); + (encoder).writeInt(((Integer) data.get(908))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(909))); + (encoder).writeInt(((Integer) data.get(910))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(911))); + (encoder).writeInt(((Integer) data.get(912))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(913))); + (encoder).writeInt(((Integer) data.get(914))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(915))); + (encoder).writeInt(((Integer) data.get(916))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(917))); + (encoder).writeInt(((Integer) data.get(918))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(919))); + (encoder).writeInt(((Integer) data.get(920))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(921))); + (encoder).writeInt(((Integer) data.get(922))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(923))); + (encoder).writeInt(((Integer) data.get(924))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(925))); + (encoder).writeInt(((Integer) data.get(926))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(927))); + (encoder).writeInt(((Integer) data.get(928))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(929))); + (encoder).writeInt(((Integer) data.get(930))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(931))); + (encoder).writeInt(((Integer) data.get(932))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(933))); + (encoder).writeInt(((Integer) data.get(934))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(935))); + (encoder).writeInt(((Integer) data.get(936))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(937))); + (encoder).writeInt(((Integer) data.get(938))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(939))); + (encoder).writeInt(((Integer) data.get(940))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(941))); + (encoder).writeInt(((Integer) data.get(942))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(943))); + (encoder).writeInt(((Integer) data.get(944))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(945))); + (encoder).writeInt(((Integer) data.get(946))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(947))); + (encoder).writeInt(((Integer) data.get(948))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(949))); + (encoder).writeInt(((Integer) data.get(950))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(951))); + (encoder).writeInt(((Integer) data.get(952))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(953))); + (encoder).writeInt(((Integer) data.get(954))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(955))); + (encoder).writeInt(((Integer) data.get(956))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(957))); + (encoder).writeInt(((Integer) data.get(958))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(959))); + (encoder).writeInt(((Integer) data.get(960))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(961))); + (encoder).writeInt(((Integer) data.get(962))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(963))); + (encoder).writeInt(((Integer) data.get(964))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(965))); + (encoder).writeInt(((Integer) data.get(966))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(967))); + (encoder).writeInt(((Integer) data.get(968))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(969))); + (encoder).writeInt(((Integer) data.get(970))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(971))); + (encoder).writeInt(((Integer) data.get(972))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(973))); + (encoder).writeInt(((Integer) data.get(974))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(975))); + (encoder).writeInt(((Integer) data.get(976))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(977))); + (encoder).writeInt(((Integer) data.get(978))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(979))); + (encoder).writeInt(((Integer) data.get(980))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(981))); + (encoder).writeInt(((Integer) data.get(982))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(983))); + (encoder).writeInt(((Integer) data.get(984))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(985))); + (encoder).writeInt(((Integer) data.get(986))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(987))); + (encoder).writeInt(((Integer) data.get(988))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(989))); + (encoder).writeInt(((Integer) data.get(990))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(991))); + (encoder).writeInt(((Integer) data.get(992))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(993))); + (encoder).writeInt(((Integer) data.get(994))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(995))); + (encoder).writeInt(((Integer) data.get(996))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(997))); + (encoder).writeInt(((Integer) data.get(998))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(999))); + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java new file mode 100644 index 000000000..f413c8dd0 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java @@ -0,0 +1,116 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + int valueToWrite0; + Object enumValue0 = data.get(0); + if (enumValue0 instanceof Enum) { + valueToWrite0 = ((Enum) enumValue0).ordinal(); + } else { + valueToWrite0 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).toString()); + } + (encoder).writeEnum(valueToWrite0); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + GenericEnumSymbol testEnumUnion0 = ((GenericEnumSymbol) data.get(1)); + if (testEnumUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((testEnumUnion0 instanceof GenericEnumSymbol)&&"com.linkedin.avro.fastserde.generated.avro.testEnum".equals(((GenericEnumSymbol) testEnumUnion0).getSchema().getFullName())) { + (encoder).writeIndex(1); + int valueToWrite1; + Object enumValue1 = testEnumUnion0; + if (enumValue1 instanceof Enum) { + valueToWrite1 = ((Enum) enumValue1).ordinal(); + } else { + valueToWrite1 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).toString()); + } + (encoder).writeEnum(valueToWrite1); + } + } + List testEnumArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testEnumArray0 == null)||testEnumArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testEnumArray0 .size()); + for (int counter0 = 0; (counter0 testEnumUnionArray0 = ((List ) data.get(3)); + (encoder).writeArrayStart(); + if ((testEnumUnionArray0 == null)||testEnumUnionArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testEnumUnionArray0 .size()); + for (int counter1 = 0; (counter1 ) testEnumUnionArray0).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof GenericEnumSymbol)&&"com.linkedin.avro.fastserde.generated.avro.testEnum".equals(((GenericEnumSymbol) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + int valueToWrite3; + Object enumValue3 = union0; + if (enumValue3 instanceof Enum) { + valueToWrite3 = ((Enum) enumValue3).ordinal(); + } else { + valueToWrite3 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue3).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue3).toString()); + } + (encoder).writeEnum(valueToWrite3); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java new file mode 100644 index 000000000..4644a7278 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java @@ -0,0 +1,88 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + GenericFixed testFixedUnion0 = ((GenericFixed) data.get(1)); + if (testFixedUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((testFixedUnion0 instanceof GenericFixed)&&"com.linkedin.avro.fastserde.generated.avro.testFixed".equals(((GenericFixed) testFixedUnion0).getSchema().getFullName())) { + (encoder).writeIndex(1); + (encoder).writeFixed(((GenericFixed) testFixedUnion0).bytes()); + } + } + List testFixedArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testFixedArray0 == null)||testFixedArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testFixedArray0 .size()); + for (int counter0 = 0; (counter0 testFixedUnionArray0 = ((List ) data.get(3)); + (encoder).writeArrayStart(); + if ((testFixedUnionArray0 == null)||testFixedUnionArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testFixedUnionArray0 .size()); + for (int counter1 = 0; (counter1 ) testFixedUnionArray0).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof GenericFixed)&&"com.linkedin.avro.fastserde.generated.avro.testFixed".equals(((GenericFixed) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + (encoder).writeFixed(((GenericFixed) union0).bytes()); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java new file mode 100644 index 000000000..defba911b --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java @@ -0,0 +1,70 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object union0 = ((Object) data.get(0)); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } else { + if (union0 instanceof CharSequence) { + (encoder).writeIndex(2); + if (((CharSequence) union0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) union0))); + } else { + (encoder).writeString(((CharSequence) union0).toString()); + } + } else { + if (union0 instanceof Integer) { + (encoder).writeIndex(3); + (encoder).writeInt(((Integer) union0)); + } + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java new file mode 100644 index 000000000..782cbd32e --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java @@ -0,0 +1,157 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import java.nio.ByteBuffer; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Integer testIntUnion0 = ((Integer) data.get(1)); + if (testIntUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeInt(((Integer) testIntUnion0)); + } + Integer testFlippedIntUnion0 = ((Integer) data.get(2)); + if (testFlippedIntUnion0 == null) { + (encoder).writeIndex(1); + (encoder).writeNull(); + } else { + (encoder).writeIndex(0); + (encoder).writeInt(((Integer) testFlippedIntUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(3)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(3)))); + } else { + (encoder).writeString(((CharSequence) data.get(3)).toString()); + } + CharSequence testStringUnion0 = ((CharSequence) data.get(4)); + if (testStringUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testStringUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringUnion0))); + } else { + (encoder).writeString(((CharSequence) testStringUnion0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeLong(((Long) data.get(5))); + Long testLongUnion0 = ((Long) data.get(6)); + if (testLongUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeLong(((Long) testLongUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeDouble(((Double) data.get(7))); + Double testDoubleUnion0 = ((Double) data.get(8)); + if (testDoubleUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeDouble(((Double) testDoubleUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFloat(((Float) data.get(9))); + Float testFloatUnion0 = ((Float) data.get(10)); + if (testFloatUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeFloat(((Float) testFloatUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeBoolean(((Boolean) data.get(11))); + Boolean testBooleanUnion0 = ((Boolean) data.get(12)); + if (testBooleanUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeBoolean(((Boolean) testBooleanUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeBytes(((ByteBuffer) data.get(13))); + ByteBuffer testBytesUnion0 = ((ByteBuffer) data.get(14)); + if (testBytesUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeBytes(((ByteBuffer) testBytesUnion0)); + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java new file mode 100644 index 000000000..8d6ed9006 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object union_field0 = ((Object) data.get(0)); + if (union_field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record1".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord10(((IndexedRecord) union_field0), (encoder), (customization)); + } else { + if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record2".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { + (encoder).writeIndex(2); + serializeRecord20(((IndexedRecord) union_field0), (encoder), (customization)); + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + } + + @SuppressWarnings("unchecked") + public void serializeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java new file mode 100644 index 000000000..1a84d11e3 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java @@ -0,0 +1,158 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List recordsArray0 = ((List ) data.get(0)); + (encoder).writeArrayStart(); + if ((recordsArray0 == null)||recordsArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsArray0 .size()); + for (int counter0 = 0; (counter0 ) recordsArray0).get(counter0); + serializeSubRecord0(subRecord0, (encoder), (customization)); + } + } + (encoder).writeArrayEnd(); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map recordsMap0 = ((Map ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMap0); + } + (encoder).writeMapStart(); + if ((recordsMap0 == null)||recordsMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsMap0 .size()); + for (CharSequence key0 : ((Map ) recordsMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord subRecord1 = null; + subRecord1 = ((Map ) recordsMap0).get(key0); + serializeSubRecord0(subRecord1, (encoder), (customization)); + } + } + (encoder).writeMapEnd(); + List recordsArrayUnion0 = ((List ) data.get(2)); + if (recordsArrayUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsArrayUnion0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) recordsArrayUnion0) == null)||((List ) recordsArrayUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) recordsArrayUnion0).size()); + for (int counter1 = 0; (counter1 <((List ) recordsArrayUnion0).size()); counter1 ++) { + (encoder).startItem(); + IndexedRecord union0 = null; + union0 = ((List )((List ) recordsArrayUnion0)).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map recordsMapUnion0 = ((Map ) data.get(3)); + if (recordsMapUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsMapUnion0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map ) recordsMapUnion0)); + } + (encoder).writeMapStart(); + if ((((Map ) recordsMapUnion0) == null)||((Map ) recordsMapUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map ) recordsMapUnion0).size()); + for (CharSequence key1 : ((Map )((Map ) recordsMapUnion0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + IndexedRecord union1 = null; + union1 = ((Map )((Map ) recordsMapUnion0)).get(key1); + if (union1 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java new file mode 100644 index 000000000..d5d638254 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java @@ -0,0 +1,230 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List> recordsArrayMap0 = ((List> ) data.get(0)); + (encoder).writeArrayStart(); + if ((recordsArrayMap0 == null)||recordsArrayMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsArrayMap0 .size()); + for (int counter0 = 0; (counter0 map0 = null; + map0 = ((List> ) recordsArrayMap0).get(counter0); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map0); + } + (encoder).writeMapStart(); + if ((map0 == null)||map0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(map0 .size()); + for (CharSequence key0 : ((Map ) map0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord union0 = null; + union0 = ((Map ) map0).get(key0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + (encoder).writeArrayEnd(); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map> recordsMapArray0 = ((Map> ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMapArray0); + } + (encoder).writeMapStart(); + if ((recordsMapArray0 == null)||recordsMapArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsMapArray0 .size()); + for (CharSequence key1 : ((Map> ) recordsMapArray0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + List array0 = null; + array0 = ((Map> ) recordsMapArray0).get(key1); + (encoder).writeArrayStart(); + if ((array0 == null)||array0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array0 .size()); + for (int counter1 = 0; (counter1 ) array0).get(counter1); + if (union1 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + (encoder).writeMapEnd(); + List> recordsArrayMapUnion0 = ((List> ) data.get(2)); + if (recordsArrayMapUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsArrayMapUnion0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List> ) recordsArrayMapUnion0) == null)||((List> ) recordsArrayMapUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List> ) recordsArrayMapUnion0).size()); + for (int counter2 = 0; (counter2 <((List> ) recordsArrayMapUnion0).size()); counter2 ++) { + (encoder).startItem(); + Map map1 = null; + map1 = ((List> )((List> ) recordsArrayMapUnion0)).get(counter2); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map1); + } + (encoder).writeMapStart(); + if ((map1 == null)||map1 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(map1 .size()); + for (CharSequence key2 : ((Map ) map1).keySet()) { + (encoder).startItem(); + (encoder).writeString(key2); + IndexedRecord union2 = null; + union2 = ((Map ) map1).get(key2); + if (union2 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union2 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union2).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union2), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + (encoder).writeArrayEnd(); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map> recordsMapArrayUnion0 = ((Map> ) data.get(3)); + if (recordsMapArrayUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsMapArrayUnion0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map> ) recordsMapArrayUnion0)); + } + (encoder).writeMapStart(); + if ((((Map> ) recordsMapArrayUnion0) == null)||((Map> ) recordsMapArrayUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map> ) recordsMapArrayUnion0).size()); + for (CharSequence key3 : ((Map> )((Map> ) recordsMapArrayUnion0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key3); + List array1 = null; + array1 = ((Map> )((Map> ) recordsMapArrayUnion0)).get(key3); + (encoder).writeArrayStart(); + if ((array1 == null)||array1 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array1 .size()); + for (int counter3 = 0; (counter3 ) array1).get(counter3); + if (union3 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union3 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union3).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union3), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + (encoder).writeMapEnd(); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java new file mode 100644 index 000000000..5ef472593 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + IndexedRecord record0 = ((IndexedRecord) data.get(0)); + if (record0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((record0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) record0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) record0), (encoder), (customization)); + } + } + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + IndexedRecord record10 = ((IndexedRecord) data.get(1)); + serializeSubRecord0(record10, (encoder), (customization)); + CharSequence field0 = ((CharSequence) data.get(2)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastSerdeEnums_GenericSerializer_957378572.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastSerdeEnums_GenericSerializer_957378572.java new file mode 100644 index 000000000..9c975afda --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastSerdeEnums_GenericSerializer_957378572.java @@ -0,0 +1,95 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeEnums_GenericSerializer_957378572 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + int valueToWrite0; + Object enumValue0 = data.get(0); + if (enumValue0 instanceof Enum) { + valueToWrite0 = ((Enum) enumValue0).ordinal(); + } else { + valueToWrite0 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).toString()); + } + (encoder).writeEnum(valueToWrite0); + serialize_FastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List arrayOfEnums0 = ((List ) data.get(1)); + if (arrayOfEnums0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (arrayOfEnums0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) arrayOfEnums0) == null)||((List ) arrayOfEnums0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) arrayOfEnums0).size()); + for (int counter0 = 0; (counter0 <((List ) arrayOfEnums0).size()); counter0 ++) { + (encoder).startItem(); + int valueToWrite1; + Object enumValue1 = ((List ) arrayOfEnums0).get(counter0); + if (enumValue1 instanceof Enum) { + valueToWrite1 = ((Enum) enumValue1).ordinal(); + } else { + valueToWrite1 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).toString()); + } + (encoder).writeEnum(valueToWrite1); + } + } + (encoder).writeArrayEnd(); + } + } + Map mapOfEnums0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfEnums0); + } + (encoder).writeMapStart(); + if ((mapOfEnums0 == null)||mapOfEnums0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfEnums0 .size()); + for (CharSequence key0 : ((Map ) mapOfEnums0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + int valueToWrite2; + Object enumValue2 = mapOfEnums0 .get(key0); + if (enumValue2 instanceof Enum) { + valueToWrite2 = ((Enum) enumValue2).ordinal(); + } else { + valueToWrite2 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue2).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue2).toString()); + } + (encoder).writeEnum(valueToWrite2); + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastSerdeFixed_GenericSerializer_504108934.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastSerdeFixed_GenericSerializer_504108934.java new file mode 100644 index 000000000..afbda5a99 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastSerdeFixed_GenericSerializer_504108934.java @@ -0,0 +1,74 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeFixed_GenericSerializer_504108934 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List arrayOfFixed0 = ((List ) data.get(1)); + if (arrayOfFixed0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (arrayOfFixed0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) arrayOfFixed0) == null)||((List ) arrayOfFixed0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) arrayOfFixed0).size()); + for (int counter0 = 0; (counter0 <((List ) arrayOfFixed0).size()); counter0 ++) { + (encoder).startItem(); + (encoder).writeFixed(((GenericFixed)((List ) arrayOfFixed0).get(counter0)).bytes()); + } + } + (encoder).writeArrayEnd(); + } + } + Map mapOfFixed0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfFixed0); + } + (encoder).writeMapStart(); + if ((mapOfFixed0 == null)||mapOfFixed0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfFixed0 .size()); + for (CharSequence key0 : ((Map ) mapOfFixed0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + (encoder).writeFixed(((GenericFixed) mapOfFixed0 .get(key0)).bytes()); + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java new file mode 100644 index 000000000..c5bb26d29 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java @@ -0,0 +1,97 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence testUnionString0 = ((CharSequence) data.get(1)); + if (testUnionString0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testUnionString0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testUnionString0))); + } else { + (encoder).writeString(((CharSequence) testUnionString0).toString()); + } + } + List testStringArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testStringArray0 == null)||testStringArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringArray0 .size()); + for (int counter0 = 0; (counter0 testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } + (encoder).writeMapStart(); + if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringMap0 .size()); + for (CharSequence key0 : ((Map ) testStringMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) testStringMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) testStringMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java new file mode 100644 index 000000000..2cab83e3c --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java @@ -0,0 +1,97 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_FastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence testUnionString0 = ((CharSequence) data.get(1)); + if (testUnionString0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testUnionString0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testUnionString0))); + } else { + (encoder).writeString(((CharSequence) testUnionString0).toString()); + } + } + List testStringArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testStringArray0 == null)||testStringArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringArray0 .size()); + for (int counter0 = 0; (counter0 testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } + (encoder).writeMapStart(); + if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringMap0 .size()); + for (CharSequence key0 : ((Map ) testStringMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) testStringMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) testStringMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/Map_of_UNION_GenericSerializer_2140000109.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/Map_of_UNION_GenericSerializer_2140000109.java new file mode 100644 index 000000000..675230ae2 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/Map_of_UNION_GenericSerializer_2140000109.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Map_of_UNION_GenericSerializer_2140000109 + implements FastSerializer> +{ + + + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } + (encoder).writeMapStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (CharSequence key0 : ((Map ) data).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord union0 = null; + union0 = ((Map ) data).get(key0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/Map_of_record_GenericSerializer_1677529043.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/Map_of_record_GenericSerializer_1677529043.java new file mode 100644 index 000000000..e7e2fbba3 --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/Map_of_record_GenericSerializer_1677529043.java @@ -0,0 +1,57 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Map_of_record_GenericSerializer_1677529043 + implements FastSerializer> +{ + + + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } + (encoder).writeMapStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (CharSequence key0 : ((Map ) data).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord record0 = null; + record0 = ((Map ) data).get(key0); + serializeRecord0(record0, (encoder), (customization)); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/StringableRecord_SpecificSerializer_842267318.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/StringableRecord_SpecificSerializer_842267318.java new file mode 100644 index 000000000..305d41cee --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/StringableRecord_SpecificSerializer_842267318.java @@ -0,0 +1,154 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord; +import com.linkedin.avro.fastserde.generated.avro.StringableRecord; +import com.linkedin.avro.fastserde.generated.avro.StringableSubRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class StringableRecord_SpecificSerializer_842267318 + implements FastSerializer +{ + + + public void serialize(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeStringableRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + serialize_StringableRecord0(data, (encoder), (customization)); + serialize_StringableRecord1(data, (encoder), (customization)); + serialize_StringableRecord2(data, (encoder), (customization)); + serialize_StringableRecord3(data, (encoder), (customization)); + serialize_StringableRecord4(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((CharSequence) data.get(1)).toString()); + (encoder).writeString(((CharSequence) data.get(2)).toString()); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord1(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((CharSequence) data.get(3)).toString()); + (encoder).writeString(((CharSequence) data.get(4)).toString()); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord2(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List urlArray0 = ((List ) data.get(5)); + (encoder).writeArrayStart(); + if ((urlArray0 == null)||urlArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(urlArray0 .size()); + for (int counter0 = 0; (counter0 urlMap0 = ((Map ) data.get(6)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(urlMap0); + } + (encoder).writeMapStart(); + if ((urlMap0 == null)||urlMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(urlMap0 .size()); + for (CharSequence key0 : ((Map ) urlMap0).keySet()) { + (encoder).startItem(); + String keyString0 = key0 .toString(); + (encoder).writeString(keyString0); + (encoder).writeString(((CharSequence) urlMap0 .get(key0)).toString()); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord3(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord0 = ((StringableSubRecord) data.get(7)); + serializeStringableSubRecord0(subRecord0, (encoder), (customization)); + AnotherSubRecord subRecordWithSubRecord0 = ((AnotherSubRecord) data.get(8)); + serializeAnotherSubRecord0(subRecordWithSubRecord0, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + serialize_StringableSubRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object nullStringIntUnion0 = ((Object) data.get(1)); + if (nullStringIntUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (nullStringIntUnion0 instanceof CharSequence) { + (encoder).writeIndex(1); + if (((CharSequence) nullStringIntUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) nullStringIntUnion0))); + } else { + (encoder).writeString(((CharSequence) nullStringIntUnion0).toString()); + } + } else { + if (nullStringIntUnion0 instanceof Integer) { + (encoder).writeIndex(2); + (encoder).writeInt(((Integer) nullStringIntUnion0)); + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeAnotherSubRecord0(AnotherSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord1 = ((StringableSubRecord) data.get(0)); + serializeStringableSubRecord0(subRecord1, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord4(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + String stringUnion0 = ((String) data.get(9)); + if (stringUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeString(((String) stringUnion0).toString()); + } + } + +} diff --git a/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/TestArrayOfFloats_GenericSerializer_1408566797.java b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/TestArrayOfFloats_GenericSerializer_1408566797.java new file mode 100644 index 000000000..04c40650a --- /dev/null +++ b/fastserde/avro-fastserde-tests16/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_6/TestArrayOfFloats_GenericSerializer_1408566797.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_6; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class TestArrayOfFloats_GenericSerializer_1408566797 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeTestArrayOfFloats0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeTestArrayOfFloats0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List array_of_float0 = ((List ) data.get(0)); + (encoder).writeArrayStart(); + if ((array_of_float0 == null)||array_of_float0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array_of_float0 .size()); + Object array0 = array_of_float0; + if (array0 instanceof PrimitiveFloatList) { + PrimitiveFloatList primitiveList0 = ((PrimitiveFloatList) array0); + if (primitiveList0 instanceof BufferBackedPrimitiveFloatList) { + BufferBackedPrimitiveFloatList bufferBackedPrimitiveFloatList = ((BufferBackedPrimitiveFloatList) primitiveList0); + bufferBackedPrimitiveFloatList.writeFloats((encoder)); + } else { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_BOOLEAN_GenericDeserializer_869749973_869749973(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveBooleanList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveBooleanList) { + array0 = ((PrimitiveBooleanList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveBooleanArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_DOUBLE_GenericDeserializer_18760307_18760307(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveDoubleList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveDoubleList) { + array0 = ((PrimitiveDoubleList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveDoubleArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_FLOAT_GenericDeserializer_1012670397_1012670397(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveFloatList array0 = null; + array0 = ((PrimitiveFloatList) BufferBackedPrimitiveFloatList.readPrimitiveFloatArray((reuse), (decoder))); + return array0; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/Array_of_INT_GenericDeserializer_1012089072_1012089072.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/Array_of_INT_GenericDeserializer_1012089072_1012089072.java new file mode 100644 index 000000000..f20090086 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/Array_of_INT_GenericDeserializer_1012089072_1012089072.java @@ -0,0 +1,43 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class Array_of_INT_GenericDeserializer_1012089072_1012089072 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Array_of_INT_GenericDeserializer_1012089072_1012089072(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveIntList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveIntList) { + array0 = ((PrimitiveIntList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_LONG_GenericDeserializer_325099267_325099267(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveLongList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveLongList) { + array0 = ((PrimitiveLongList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveLongArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_TestRecord_SpecificDeserializer_1088113243_1088113243(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema arrayArrayElemSchema0; + private final Schema arrayElemOptionSchema0; + private final Schema field0; + + public Array_of_UNION_GenericDeserializer_777827233_777827233(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArrayElemSchema0 = readerSchema.getElementType(); + this.arrayElemOptionSchema0 = arrayArrayElemSchema0 .getTypes().get(1); + this.field0 = arrayElemOptionSchema0 .getField("field").schema(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_UNION_SpecificDeserializer_1277939469_1277939469(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex15 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex17)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex21 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex21)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex23 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex23)); + } + } + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex25 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex25 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex25 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex25)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema unionOptionArrayElemSchema0; + + public Array_of_record_GenericDeserializer_1606337179_2018567528(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOptionArrayElemSchema0 = readerSchema.getElementType(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":{\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}}"); + } else { + if (unionIndex0 == 1) { + List unionOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + unionOption0 = ((List)(reuse)); + unionOption0 .clear(); + } else { + unionOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + private final Schema arrayArrayElemSchema0; + private final Schema field0; + + public Array_of_record_GenericDeserializer_477614132_477614132(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArrayElemSchema0 = readerSchema.getElementType(); + this.field0 = arrayArrayElemSchema0 .getField("field").schema(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema f00; + private final Schema f10; + private final Schema f20; + private final Schema f30; + private final Schema f40; + private final Schema f50; + private final Schema f60; + private final Schema f70; + private final Schema f80; + private final Schema f90; + private final Schema f100; + private final Schema f110; + private final Schema f120; + private final Schema f130; + private final Schema f140; + private final Schema f150; + private final Schema f160; + private final Schema f170; + private final Schema f180; + private final Schema f190; + private final Schema f200; + private final Schema f210; + private final Schema f220; + private final Schema f230; + private final Schema f240; + private final Schema f250; + private final Schema f260; + private final Schema f270; + private final Schema f280; + private final Schema f290; + private final Schema f300; + private final Schema f310; + private final Schema f320; + private final Schema f330; + private final Schema f340; + private final Schema f350; + private final Schema f360; + private final Schema f370; + private final Schema f380; + private final Schema f390; + private final Schema f400; + private final Schema f410; + private final Schema f420; + private final Schema f430; + private final Schema f440; + private final Schema f450; + private final Schema f460; + private final Schema f470; + private final Schema f480; + private final Schema f490; + private final Schema f500; + private final Schema f510; + private final Schema f520; + private final Schema f530; + private final Schema f540; + private final Schema f550; + private final Schema f560; + private final Schema f570; + private final Schema f580; + private final Schema f590; + private final Schema f600; + private final Schema f610; + private final Schema f620; + private final Schema f630; + private final Schema f640; + private final Schema f650; + private final Schema f660; + private final Schema f670; + private final Schema f680; + private final Schema f690; + private final Schema f700; + private final Schema f710; + private final Schema f720; + private final Schema f730; + private final Schema f740; + private final Schema f750; + private final Schema f760; + private final Schema f770; + private final Schema f780; + private final Schema f790; + private final Schema f800; + private final Schema f810; + private final Schema f820; + private final Schema f830; + private final Schema f840; + private final Schema f850; + private final Schema f860; + private final Schema f870; + private final Schema f880; + private final Schema f890; + private final Schema f900; + private final Schema f910; + private final Schema f920; + private final Schema f930; + private final Schema f940; + private final Schema f950; + private final Schema f960; + private final Schema f970; + private final Schema f980; + private final Schema f990; + private final Schema f1000; + private final Schema f1010; + private final Schema f1020; + private final Schema f1030; + private final Schema f1040; + private final Schema f1050; + private final Schema f1060; + private final Schema f1070; + private final Schema f1080; + private final Schema f1090; + private final Schema f1100; + private final Schema f1110; + private final Schema f1120; + private final Schema f1130; + private final Schema f1140; + private final Schema f1150; + private final Schema f1160; + private final Schema f1170; + private final Schema f1180; + private final Schema f1190; + private final Schema f1200; + private final Schema f1210; + private final Schema f1220; + private final Schema f1230; + private final Schema f1240; + private final Schema f1250; + private final Schema f1260; + private final Schema f1270; + private final Schema f1280; + private final Schema f1290; + private final Schema f1300; + private final Schema f1310; + private final Schema f1320; + private final Schema f1330; + private final Schema f1340; + private final Schema f1350; + private final Schema f1360; + private final Schema f1370; + private final Schema f1380; + private final Schema f1390; + private final Schema f1400; + private final Schema f1410; + private final Schema f1420; + private final Schema f1430; + private final Schema f1440; + private final Schema f1450; + private final Schema f1460; + private final Schema f1470; + private final Schema f1480; + private final Schema f1490; + private final Schema f1500; + private final Schema f1510; + private final Schema f1520; + private final Schema f1530; + private final Schema f1540; + private final Schema f1550; + private final Schema f1560; + private final Schema f1570; + private final Schema f1580; + private final Schema f1590; + private final Schema f1600; + private final Schema f1610; + private final Schema f1620; + private final Schema f1630; + private final Schema f1640; + private final Schema f1650; + private final Schema f1660; + private final Schema f1670; + private final Schema f1680; + private final Schema f1690; + private final Schema f1700; + private final Schema f1710; + private final Schema f1720; + private final Schema f1730; + private final Schema f1740; + private final Schema f1750; + private final Schema f1760; + private final Schema f1770; + private final Schema f1780; + private final Schema f1790; + private final Schema f1800; + private final Schema f1810; + private final Schema f1820; + private final Schema f1830; + private final Schema f1840; + private final Schema f1850; + private final Schema f1860; + private final Schema f1870; + private final Schema f1880; + private final Schema f1890; + private final Schema f1900; + private final Schema f1910; + private final Schema f1920; + private final Schema f1930; + private final Schema f1940; + private final Schema f1950; + private final Schema f1960; + private final Schema f1970; + private final Schema f1980; + private final Schema f1990; + private final Schema f2000; + private final Schema f2010; + private final Schema f2020; + private final Schema f2030; + private final Schema f2040; + private final Schema f2050; + private final Schema f2060; + private final Schema f2070; + private final Schema f2080; + private final Schema f2090; + private final Schema f2100; + private final Schema f2110; + private final Schema f2120; + private final Schema f2130; + private final Schema f2140; + private final Schema f2150; + private final Schema f2160; + private final Schema f2170; + private final Schema f2180; + private final Schema f2190; + private final Schema f2200; + private final Schema f2210; + private final Schema f2220; + private final Schema f2230; + private final Schema f2240; + private final Schema f2250; + private final Schema f2260; + private final Schema f2270; + private final Schema f2280; + private final Schema f2290; + private final Schema f2300; + private final Schema f2310; + private final Schema f2320; + private final Schema f2330; + private final Schema f2340; + private final Schema f2350; + private final Schema f2360; + private final Schema f2370; + private final Schema f2380; + private final Schema f2390; + private final Schema f2400; + private final Schema f2410; + private final Schema f2420; + private final Schema f2430; + private final Schema f2440; + private final Schema f2450; + private final Schema f2460; + private final Schema f2470; + private final Schema f2480; + private final Schema f2490; + private final Schema f2500; + private final Schema f2510; + private final Schema f2520; + private final Schema f2530; + private final Schema f2540; + private final Schema f2550; + private final Schema f2560; + private final Schema f2570; + private final Schema f2580; + private final Schema f2590; + private final Schema f2600; + private final Schema f2610; + private final Schema f2620; + private final Schema f2630; + private final Schema f2640; + private final Schema f2650; + private final Schema f2660; + private final Schema f2670; + private final Schema f2680; + private final Schema f2690; + private final Schema f2700; + private final Schema f2710; + private final Schema f2720; + private final Schema f2730; + private final Schema f2740; + private final Schema f2750; + private final Schema f2760; + private final Schema f2770; + private final Schema f2780; + private final Schema f2790; + private final Schema f2800; + private final Schema f2810; + private final Schema f2820; + private final Schema f2830; + private final Schema f2840; + private final Schema f2850; + private final Schema f2860; + private final Schema f2870; + private final Schema f2880; + private final Schema f2890; + private final Schema f2900; + private final Schema f2910; + private final Schema f2920; + private final Schema f2930; + private final Schema f2940; + private final Schema f2950; + private final Schema f2960; + private final Schema f2970; + private final Schema f2980; + private final Schema f2990; + private final Schema f3000; + private final Schema f3010; + private final Schema f3020; + private final Schema f3030; + private final Schema f3040; + private final Schema f3050; + private final Schema f3060; + private final Schema f3070; + private final Schema f3080; + private final Schema f3090; + private final Schema f3100; + private final Schema f3110; + private final Schema f3120; + private final Schema f3130; + private final Schema f3140; + private final Schema f3150; + private final Schema f3160; + private final Schema f3170; + private final Schema f3180; + private final Schema f3190; + private final Schema f3200; + private final Schema f3210; + private final Schema f3220; + private final Schema f3230; + private final Schema f3240; + private final Schema f3250; + private final Schema f3260; + private final Schema f3270; + private final Schema f3280; + private final Schema f3290; + private final Schema f3300; + private final Schema f3310; + private final Schema f3320; + private final Schema f3330; + private final Schema f3340; + private final Schema f3350; + private final Schema f3360; + private final Schema f3370; + private final Schema f3380; + private final Schema f3390; + private final Schema f3400; + private final Schema f3410; + private final Schema f3420; + private final Schema f3430; + private final Schema f3440; + private final Schema f3450; + private final Schema f3460; + private final Schema f3470; + private final Schema f3480; + private final Schema f3490; + private final Schema f3500; + private final Schema f3510; + private final Schema f3520; + private final Schema f3530; + private final Schema f3540; + private final Schema f3550; + private final Schema f3560; + private final Schema f3570; + private final Schema f3580; + private final Schema f3590; + private final Schema f3600; + private final Schema f3610; + private final Schema f3620; + private final Schema f3630; + private final Schema f3640; + private final Schema f3650; + private final Schema f3660; + private final Schema f3670; + private final Schema f3680; + private final Schema f3690; + private final Schema f3700; + private final Schema f3710; + private final Schema f3720; + private final Schema f3730; + private final Schema f3740; + private final Schema f3750; + private final Schema f3760; + private final Schema f3770; + private final Schema f3780; + private final Schema f3790; + private final Schema f3800; + private final Schema f3810; + private final Schema f3820; + private final Schema f3830; + private final Schema f3840; + private final Schema f3850; + private final Schema f3860; + private final Schema f3870; + private final Schema f3880; + private final Schema f3890; + private final Schema f3900; + private final Schema f3910; + private final Schema f3920; + private final Schema f3930; + private final Schema f3940; + private final Schema f3950; + private final Schema f3960; + private final Schema f3970; + private final Schema f3980; + private final Schema f3990; + private final Schema f4000; + private final Schema f4010; + private final Schema f4020; + private final Schema f4030; + private final Schema f4040; + private final Schema f4050; + private final Schema f4060; + private final Schema f4070; + private final Schema f4080; + private final Schema f4090; + private final Schema f4100; + private final Schema f4110; + private final Schema f4120; + private final Schema f4130; + private final Schema f4140; + private final Schema f4150; + private final Schema f4160; + private final Schema f4170; + private final Schema f4180; + private final Schema f4190; + private final Schema f4200; + private final Schema f4210; + private final Schema f4220; + private final Schema f4230; + private final Schema f4240; + private final Schema f4250; + private final Schema f4260; + private final Schema f4270; + private final Schema f4280; + private final Schema f4290; + private final Schema f4300; + private final Schema f4310; + private final Schema f4320; + private final Schema f4330; + private final Schema f4340; + private final Schema f4350; + private final Schema f4360; + private final Schema f4370; + private final Schema f4380; + private final Schema f4390; + private final Schema f4400; + private final Schema f4410; + private final Schema f4420; + private final Schema f4430; + private final Schema f4440; + private final Schema f4450; + private final Schema f4460; + private final Schema f4470; + private final Schema f4480; + private final Schema f4490; + private final Schema f4500; + private final Schema f4510; + private final Schema f4520; + private final Schema f4530; + private final Schema f4540; + private final Schema f4550; + private final Schema f4560; + private final Schema f4570; + private final Schema f4580; + private final Schema f4590; + private final Schema f4600; + private final Schema f4610; + private final Schema f4620; + private final Schema f4630; + private final Schema f4640; + private final Schema f4650; + private final Schema f4660; + private final Schema f4670; + private final Schema f4680; + private final Schema f4690; + private final Schema f4700; + private final Schema f4710; + private final Schema f4720; + private final Schema f4730; + private final Schema f4740; + private final Schema f4750; + private final Schema f4760; + private final Schema f4770; + private final Schema f4780; + private final Schema f4790; + private final Schema f4800; + private final Schema f4810; + private final Schema f4820; + private final Schema f4830; + private final Schema f4840; + private final Schema f4850; + private final Schema f4860; + private final Schema f4870; + private final Schema f4880; + private final Schema f4890; + private final Schema f4900; + private final Schema f4910; + private final Schema f4920; + private final Schema f4930; + private final Schema f4940; + private final Schema f4950; + private final Schema f4960; + private final Schema f4970; + private final Schema f4980; + private final Schema f4990; + private final Schema f5000; + private final Schema f5010; + private final Schema f5020; + private final Schema f5030; + private final Schema f5040; + private final Schema f5050; + private final Schema f5060; + private final Schema f5070; + private final Schema f5080; + private final Schema f5090; + private final Schema f5100; + private final Schema f5110; + private final Schema f5120; + private final Schema f5130; + private final Schema f5140; + private final Schema f5150; + private final Schema f5160; + private final Schema f5170; + private final Schema f5180; + private final Schema f5190; + private final Schema f5200; + private final Schema f5210; + private final Schema f5220; + private final Schema f5230; + private final Schema f5240; + private final Schema f5250; + private final Schema f5260; + private final Schema f5270; + private final Schema f5280; + private final Schema f5290; + private final Schema f5300; + private final Schema f5310; + private final Schema f5320; + private final Schema f5330; + private final Schema f5340; + private final Schema f5350; + private final Schema f5360; + private final Schema f5370; + private final Schema f5380; + private final Schema f5390; + private final Schema f5400; + private final Schema f5410; + private final Schema f5420; + private final Schema f5430; + private final Schema f5440; + private final Schema f5450; + private final Schema f5460; + private final Schema f5470; + private final Schema f5480; + private final Schema f5490; + private final Schema f5500; + private final Schema f5510; + private final Schema f5520; + private final Schema f5530; + private final Schema f5540; + private final Schema f5550; + private final Schema f5560; + private final Schema f5570; + private final Schema f5580; + private final Schema f5590; + private final Schema f5600; + private final Schema f5610; + private final Schema f5620; + private final Schema f5630; + private final Schema f5640; + private final Schema f5650; + private final Schema f5660; + private final Schema f5670; + private final Schema f5680; + private final Schema f5690; + private final Schema f5700; + private final Schema f5710; + private final Schema f5720; + private final Schema f5730; + private final Schema f5740; + private final Schema f5750; + private final Schema f5760; + private final Schema f5770; + private final Schema f5780; + private final Schema f5790; + private final Schema f5800; + private final Schema f5810; + private final Schema f5820; + private final Schema f5830; + private final Schema f5840; + private final Schema f5850; + private final Schema f5860; + private final Schema f5870; + private final Schema f5880; + private final Schema f5890; + private final Schema f5900; + private final Schema f5910; + private final Schema f5920; + private final Schema f5930; + private final Schema f5940; + private final Schema f5950; + private final Schema f5960; + private final Schema f5970; + private final Schema f5980; + private final Schema f5990; + private final Schema f6000; + private final Schema f6010; + private final Schema f6020; + private final Schema f6030; + private final Schema f6040; + private final Schema f6050; + private final Schema f6060; + private final Schema f6070; + private final Schema f6080; + private final Schema f6090; + private final Schema f6100; + private final Schema f6110; + private final Schema f6120; + private final Schema f6130; + private final Schema f6140; + private final Schema f6150; + private final Schema f6160; + private final Schema f6170; + private final Schema f6180; + private final Schema f6190; + private final Schema f6200; + private final Schema f6210; + private final Schema f6220; + private final Schema f6230; + private final Schema f6240; + private final Schema f6250; + private final Schema f6260; + private final Schema f6270; + private final Schema f6280; + private final Schema f6290; + private final Schema f6300; + private final Schema f6310; + private final Schema f6320; + private final Schema f6330; + private final Schema f6340; + private final Schema f6350; + private final Schema f6360; + private final Schema f6370; + private final Schema f6380; + private final Schema f6390; + private final Schema f6400; + private final Schema f6410; + private final Schema f6420; + private final Schema f6430; + private final Schema f6440; + private final Schema f6450; + private final Schema f6460; + private final Schema f6470; + private final Schema f6480; + private final Schema f6490; + private final Schema f6500; + private final Schema f6510; + private final Schema f6520; + private final Schema f6530; + private final Schema f6540; + private final Schema f6550; + private final Schema f6560; + private final Schema f6570; + private final Schema f6580; + private final Schema f6590; + private final Schema f6600; + private final Schema f6610; + private final Schema f6620; + private final Schema f6630; + private final Schema f6640; + private final Schema f6650; + private final Schema f6660; + private final Schema f6670; + private final Schema f6680; + private final Schema f6690; + private final Schema f6700; + private final Schema f6710; + private final Schema f6720; + private final Schema f6730; + private final Schema f6740; + private final Schema f6750; + private final Schema f6760; + private final Schema f6770; + private final Schema f6780; + private final Schema f6790; + private final Schema f6800; + private final Schema f6810; + private final Schema f6820; + private final Schema f6830; + private final Schema f6840; + private final Schema f6850; + private final Schema f6860; + private final Schema f6870; + private final Schema f6880; + private final Schema f6890; + private final Schema f6900; + private final Schema f6910; + private final Schema f6920; + private final Schema f6930; + private final Schema f6940; + private final Schema f6950; + private final Schema f6960; + private final Schema f6970; + private final Schema f6980; + private final Schema f6990; + private final Schema f7000; + private final Schema f7010; + private final Schema f7020; + private final Schema f7030; + private final Schema f7040; + private final Schema f7050; + private final Schema f7060; + private final Schema f7070; + private final Schema f7080; + private final Schema f7090; + private final Schema f7100; + private final Schema f7110; + private final Schema f7120; + private final Schema f7130; + private final Schema f7140; + private final Schema f7150; + private final Schema f7160; + private final Schema f7170; + private final Schema f7180; + private final Schema f7190; + private final Schema f7200; + private final Schema f7210; + private final Schema f7220; + private final Schema f7230; + private final Schema f7240; + private final Schema f7250; + private final Schema f7260; + private final Schema f7270; + private final Schema f7280; + private final Schema f7290; + private final Schema f7300; + private final Schema f7310; + private final Schema f7320; + private final Schema f7330; + private final Schema f7340; + private final Schema f7350; + private final Schema f7360; + private final Schema f7370; + private final Schema f7380; + private final Schema f7390; + private final Schema f7400; + private final Schema f7410; + private final Schema f7420; + private final Schema f7430; + private final Schema f7440; + private final Schema f7450; + private final Schema f7460; + private final Schema f7470; + private final Schema f7480; + private final Schema f7490; + private final Schema f7500; + private final Schema f7510; + private final Schema f7520; + private final Schema f7530; + private final Schema f7540; + private final Schema f7550; + private final Schema f7560; + private final Schema f7570; + private final Schema f7580; + private final Schema f7590; + private final Schema f7600; + private final Schema f7610; + private final Schema f7620; + private final Schema f7630; + private final Schema f7640; + private final Schema f7650; + private final Schema f7660; + private final Schema f7670; + private final Schema f7680; + private final Schema f7690; + private final Schema f7700; + private final Schema f7710; + private final Schema f7720; + private final Schema f7730; + private final Schema f7740; + private final Schema f7750; + private final Schema f7760; + private final Schema f7770; + private final Schema f7780; + private final Schema f7790; + private final Schema f7800; + private final Schema f7810; + private final Schema f7820; + private final Schema f7830; + private final Schema f7840; + private final Schema f7850; + private final Schema f7860; + private final Schema f7870; + private final Schema f7880; + private final Schema f7890; + private final Schema f7900; + private final Schema f7910; + private final Schema f7920; + private final Schema f7930; + private final Schema f7940; + private final Schema f7950; + private final Schema f7960; + private final Schema f7970; + private final Schema f7980; + private final Schema f7990; + private final Schema f8000; + private final Schema f8010; + private final Schema f8020; + private final Schema f8030; + private final Schema f8040; + private final Schema f8050; + private final Schema f8060; + private final Schema f8070; + private final Schema f8080; + private final Schema f8090; + private final Schema f8100; + private final Schema f8110; + private final Schema f8120; + private final Schema f8130; + private final Schema f8140; + private final Schema f8150; + private final Schema f8160; + private final Schema f8170; + private final Schema f8180; + private final Schema f8190; + private final Schema f8200; + private final Schema f8210; + private final Schema f8220; + private final Schema f8230; + private final Schema f8240; + private final Schema f8250; + private final Schema f8260; + private final Schema f8270; + private final Schema f8280; + private final Schema f8290; + private final Schema f8300; + private final Schema f8310; + private final Schema f8320; + private final Schema f8330; + private final Schema f8340; + private final Schema f8350; + private final Schema f8360; + private final Schema f8370; + private final Schema f8380; + private final Schema f8390; + private final Schema f8400; + private final Schema f8410; + private final Schema f8420; + private final Schema f8430; + private final Schema f8440; + private final Schema f8450; + private final Schema f8460; + private final Schema f8470; + private final Schema f8480; + private final Schema f8490; + private final Schema f8500; + private final Schema f8510; + private final Schema f8520; + private final Schema f8530; + private final Schema f8540; + private final Schema f8550; + private final Schema f8560; + private final Schema f8570; + private final Schema f8580; + private final Schema f8590; + private final Schema f8600; + private final Schema f8610; + private final Schema f8620; + private final Schema f8630; + private final Schema f8640; + private final Schema f8650; + private final Schema f8660; + private final Schema f8670; + private final Schema f8680; + private final Schema f8690; + private final Schema f8700; + private final Schema f8710; + private final Schema f8720; + private final Schema f8730; + private final Schema f8740; + private final Schema f8750; + private final Schema f8760; + private final Schema f8770; + private final Schema f8780; + private final Schema f8790; + private final Schema f8800; + private final Schema f8810; + private final Schema f8820; + private final Schema f8830; + private final Schema f8840; + private final Schema f8850; + private final Schema f8860; + private final Schema f8870; + private final Schema f8880; + private final Schema f8890; + private final Schema f8900; + private final Schema f8910; + private final Schema f8920; + private final Schema f8930; + private final Schema f8940; + private final Schema f8950; + private final Schema f8960; + private final Schema f8970; + private final Schema f8980; + private final Schema f8990; + private final Schema f9000; + private final Schema f9010; + private final Schema f9020; + private final Schema f9030; + private final Schema f9040; + private final Schema f9050; + private final Schema f9060; + private final Schema f9070; + private final Schema f9080; + private final Schema f9090; + private final Schema f9100; + private final Schema f9110; + private final Schema f9120; + private final Schema f9130; + private final Schema f9140; + private final Schema f9150; + private final Schema f9160; + private final Schema f9170; + private final Schema f9180; + private final Schema f9190; + private final Schema f9200; + private final Schema f9210; + private final Schema f9220; + private final Schema f9230; + private final Schema f9240; + private final Schema f9250; + private final Schema f9260; + private final Schema f9270; + private final Schema f9280; + private final Schema f9290; + private final Schema f9300; + private final Schema f9310; + private final Schema f9320; + private final Schema f9330; + private final Schema f9340; + private final Schema f9350; + private final Schema f9360; + private final Schema f9370; + private final Schema f9380; + private final Schema f9390; + private final Schema f9400; + private final Schema f9410; + private final Schema f9420; + private final Schema f9430; + private final Schema f9440; + private final Schema f9450; + private final Schema f9460; + private final Schema f9470; + private final Schema f9480; + private final Schema f9490; + private final Schema f9500; + private final Schema f9510; + private final Schema f9520; + private final Schema f9530; + private final Schema f9540; + private final Schema f9550; + private final Schema f9560; + private final Schema f9570; + private final Schema f9580; + private final Schema f9590; + private final Schema f9600; + private final Schema f9610; + private final Schema f9620; + private final Schema f9630; + private final Schema f9640; + private final Schema f9650; + private final Schema f9660; + private final Schema f9670; + private final Schema f9680; + private final Schema f9690; + private final Schema f9700; + private final Schema f9710; + private final Schema f9720; + private final Schema f9730; + private final Schema f9740; + private final Schema f9750; + private final Schema f9760; + private final Schema f9770; + private final Schema f9780; + private final Schema f9790; + private final Schema f9800; + private final Schema f9810; + private final Schema f9820; + private final Schema f9830; + private final Schema f9840; + private final Schema f9850; + private final Schema f9860; + private final Schema f9870; + private final Schema f9880; + private final Schema f9890; + private final Schema f9900; + private final Schema f9910; + private final Schema f9920; + private final Schema f9930; + private final Schema f9940; + private final Schema f9950; + private final Schema f9960; + private final Schema f9970; + private final Schema f9980; + private final Schema f9990; + + public FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema_GenericDeserializer_836892732_836892732(Schema readerSchema) { + this.readerSchema = readerSchema; + this.f00 = readerSchema.getField("F0").schema(); + this.f10 = readerSchema.getField("F1").schema(); + this.f20 = readerSchema.getField("F2").schema(); + this.f30 = readerSchema.getField("F3").schema(); + this.f40 = readerSchema.getField("F4").schema(); + this.f50 = readerSchema.getField("F5").schema(); + this.f60 = readerSchema.getField("F6").schema(); + this.f70 = readerSchema.getField("F7").schema(); + this.f80 = readerSchema.getField("F8").schema(); + this.f90 = readerSchema.getField("F9").schema(); + this.f100 = readerSchema.getField("F10").schema(); + this.f110 = readerSchema.getField("F11").schema(); + this.f120 = readerSchema.getField("F12").schema(); + this.f130 = readerSchema.getField("F13").schema(); + this.f140 = readerSchema.getField("F14").schema(); + this.f150 = readerSchema.getField("F15").schema(); + this.f160 = readerSchema.getField("F16").schema(); + this.f170 = readerSchema.getField("F17").schema(); + this.f180 = readerSchema.getField("F18").schema(); + this.f190 = readerSchema.getField("F19").schema(); + this.f200 = readerSchema.getField("F20").schema(); + this.f210 = readerSchema.getField("F21").schema(); + this.f220 = readerSchema.getField("F22").schema(); + this.f230 = readerSchema.getField("F23").schema(); + this.f240 = readerSchema.getField("F24").schema(); + this.f250 = readerSchema.getField("F25").schema(); + this.f260 = readerSchema.getField("F26").schema(); + this.f270 = readerSchema.getField("F27").schema(); + this.f280 = readerSchema.getField("F28").schema(); + this.f290 = readerSchema.getField("F29").schema(); + this.f300 = readerSchema.getField("F30").schema(); + this.f310 = readerSchema.getField("F31").schema(); + this.f320 = readerSchema.getField("F32").schema(); + this.f330 = readerSchema.getField("F33").schema(); + this.f340 = readerSchema.getField("F34").schema(); + this.f350 = readerSchema.getField("F35").schema(); + this.f360 = readerSchema.getField("F36").schema(); + this.f370 = readerSchema.getField("F37").schema(); + this.f380 = readerSchema.getField("F38").schema(); + this.f390 = readerSchema.getField("F39").schema(); + this.f400 = readerSchema.getField("F40").schema(); + this.f410 = readerSchema.getField("F41").schema(); + this.f420 = readerSchema.getField("F42").schema(); + this.f430 = readerSchema.getField("F43").schema(); + this.f440 = readerSchema.getField("F44").schema(); + this.f450 = readerSchema.getField("F45").schema(); + this.f460 = readerSchema.getField("F46").schema(); + this.f470 = readerSchema.getField("F47").schema(); + this.f480 = readerSchema.getField("F48").schema(); + this.f490 = readerSchema.getField("F49").schema(); + this.f500 = readerSchema.getField("F50").schema(); + this.f510 = readerSchema.getField("F51").schema(); + this.f520 = readerSchema.getField("F52").schema(); + this.f530 = readerSchema.getField("F53").schema(); + this.f540 = readerSchema.getField("F54").schema(); + this.f550 = readerSchema.getField("F55").schema(); + this.f560 = readerSchema.getField("F56").schema(); + this.f570 = readerSchema.getField("F57").schema(); + this.f580 = readerSchema.getField("F58").schema(); + this.f590 = readerSchema.getField("F59").schema(); + this.f600 = readerSchema.getField("F60").schema(); + this.f610 = readerSchema.getField("F61").schema(); + this.f620 = readerSchema.getField("F62").schema(); + this.f630 = readerSchema.getField("F63").schema(); + this.f640 = readerSchema.getField("F64").schema(); + this.f650 = readerSchema.getField("F65").schema(); + this.f660 = readerSchema.getField("F66").schema(); + this.f670 = readerSchema.getField("F67").schema(); + this.f680 = readerSchema.getField("F68").schema(); + this.f690 = readerSchema.getField("F69").schema(); + this.f700 = readerSchema.getField("F70").schema(); + this.f710 = readerSchema.getField("F71").schema(); + this.f720 = readerSchema.getField("F72").schema(); + this.f730 = readerSchema.getField("F73").schema(); + this.f740 = readerSchema.getField("F74").schema(); + this.f750 = readerSchema.getField("F75").schema(); + this.f760 = readerSchema.getField("F76").schema(); + this.f770 = readerSchema.getField("F77").schema(); + this.f780 = readerSchema.getField("F78").schema(); + this.f790 = readerSchema.getField("F79").schema(); + this.f800 = readerSchema.getField("F80").schema(); + this.f810 = readerSchema.getField("F81").schema(); + this.f820 = readerSchema.getField("F82").schema(); + this.f830 = readerSchema.getField("F83").schema(); + this.f840 = readerSchema.getField("F84").schema(); + this.f850 = readerSchema.getField("F85").schema(); + this.f860 = readerSchema.getField("F86").schema(); + this.f870 = readerSchema.getField("F87").schema(); + this.f880 = readerSchema.getField("F88").schema(); + this.f890 = readerSchema.getField("F89").schema(); + this.f900 = readerSchema.getField("F90").schema(); + this.f910 = readerSchema.getField("F91").schema(); + this.f920 = readerSchema.getField("F92").schema(); + this.f930 = readerSchema.getField("F93").schema(); + this.f940 = readerSchema.getField("F94").schema(); + this.f950 = readerSchema.getField("F95").schema(); + this.f960 = readerSchema.getField("F96").schema(); + this.f970 = readerSchema.getField("F97").schema(); + this.f980 = readerSchema.getField("F98").schema(); + this.f990 = readerSchema.getField("F99").schema(); + this.f1000 = readerSchema.getField("F100").schema(); + this.f1010 = readerSchema.getField("F101").schema(); + this.f1020 = readerSchema.getField("F102").schema(); + this.f1030 = readerSchema.getField("F103").schema(); + this.f1040 = readerSchema.getField("F104").schema(); + this.f1050 = readerSchema.getField("F105").schema(); + this.f1060 = readerSchema.getField("F106").schema(); + this.f1070 = readerSchema.getField("F107").schema(); + this.f1080 = readerSchema.getField("F108").schema(); + this.f1090 = readerSchema.getField("F109").schema(); + this.f1100 = readerSchema.getField("F110").schema(); + this.f1110 = readerSchema.getField("F111").schema(); + this.f1120 = readerSchema.getField("F112").schema(); + this.f1130 = readerSchema.getField("F113").schema(); + this.f1140 = readerSchema.getField("F114").schema(); + this.f1150 = readerSchema.getField("F115").schema(); + this.f1160 = readerSchema.getField("F116").schema(); + this.f1170 = readerSchema.getField("F117").schema(); + this.f1180 = readerSchema.getField("F118").schema(); + this.f1190 = readerSchema.getField("F119").schema(); + this.f1200 = readerSchema.getField("F120").schema(); + this.f1210 = readerSchema.getField("F121").schema(); + this.f1220 = readerSchema.getField("F122").schema(); + this.f1230 = readerSchema.getField("F123").schema(); + this.f1240 = readerSchema.getField("F124").schema(); + this.f1250 = readerSchema.getField("F125").schema(); + this.f1260 = readerSchema.getField("F126").schema(); + this.f1270 = readerSchema.getField("F127").schema(); + this.f1280 = readerSchema.getField("F128").schema(); + this.f1290 = readerSchema.getField("F129").schema(); + this.f1300 = readerSchema.getField("F130").schema(); + this.f1310 = readerSchema.getField("F131").schema(); + this.f1320 = readerSchema.getField("F132").schema(); + this.f1330 = readerSchema.getField("F133").schema(); + this.f1340 = readerSchema.getField("F134").schema(); + this.f1350 = readerSchema.getField("F135").schema(); + this.f1360 = readerSchema.getField("F136").schema(); + this.f1370 = readerSchema.getField("F137").schema(); + this.f1380 = readerSchema.getField("F138").schema(); + this.f1390 = readerSchema.getField("F139").schema(); + this.f1400 = readerSchema.getField("F140").schema(); + this.f1410 = readerSchema.getField("F141").schema(); + this.f1420 = readerSchema.getField("F142").schema(); + this.f1430 = readerSchema.getField("F143").schema(); + this.f1440 = readerSchema.getField("F144").schema(); + this.f1450 = readerSchema.getField("F145").schema(); + this.f1460 = readerSchema.getField("F146").schema(); + this.f1470 = readerSchema.getField("F147").schema(); + this.f1480 = readerSchema.getField("F148").schema(); + this.f1490 = readerSchema.getField("F149").schema(); + this.f1500 = readerSchema.getField("F150").schema(); + this.f1510 = readerSchema.getField("F151").schema(); + this.f1520 = readerSchema.getField("F152").schema(); + this.f1530 = readerSchema.getField("F153").schema(); + this.f1540 = readerSchema.getField("F154").schema(); + this.f1550 = readerSchema.getField("F155").schema(); + this.f1560 = readerSchema.getField("F156").schema(); + this.f1570 = readerSchema.getField("F157").schema(); + this.f1580 = readerSchema.getField("F158").schema(); + this.f1590 = readerSchema.getField("F159").schema(); + this.f1600 = readerSchema.getField("F160").schema(); + this.f1610 = readerSchema.getField("F161").schema(); + this.f1620 = readerSchema.getField("F162").schema(); + this.f1630 = readerSchema.getField("F163").schema(); + this.f1640 = readerSchema.getField("F164").schema(); + this.f1650 = readerSchema.getField("F165").schema(); + this.f1660 = readerSchema.getField("F166").schema(); + this.f1670 = readerSchema.getField("F167").schema(); + this.f1680 = readerSchema.getField("F168").schema(); + this.f1690 = readerSchema.getField("F169").schema(); + this.f1700 = readerSchema.getField("F170").schema(); + this.f1710 = readerSchema.getField("F171").schema(); + this.f1720 = readerSchema.getField("F172").schema(); + this.f1730 = readerSchema.getField("F173").schema(); + this.f1740 = readerSchema.getField("F174").schema(); + this.f1750 = readerSchema.getField("F175").schema(); + this.f1760 = readerSchema.getField("F176").schema(); + this.f1770 = readerSchema.getField("F177").schema(); + this.f1780 = readerSchema.getField("F178").schema(); + this.f1790 = readerSchema.getField("F179").schema(); + this.f1800 = readerSchema.getField("F180").schema(); + this.f1810 = readerSchema.getField("F181").schema(); + this.f1820 = readerSchema.getField("F182").schema(); + this.f1830 = readerSchema.getField("F183").schema(); + this.f1840 = readerSchema.getField("F184").schema(); + this.f1850 = readerSchema.getField("F185").schema(); + this.f1860 = readerSchema.getField("F186").schema(); + this.f1870 = readerSchema.getField("F187").schema(); + this.f1880 = readerSchema.getField("F188").schema(); + this.f1890 = readerSchema.getField("F189").schema(); + this.f1900 = readerSchema.getField("F190").schema(); + this.f1910 = readerSchema.getField("F191").schema(); + this.f1920 = readerSchema.getField("F192").schema(); + this.f1930 = readerSchema.getField("F193").schema(); + this.f1940 = readerSchema.getField("F194").schema(); + this.f1950 = readerSchema.getField("F195").schema(); + this.f1960 = readerSchema.getField("F196").schema(); + this.f1970 = readerSchema.getField("F197").schema(); + this.f1980 = readerSchema.getField("F198").schema(); + this.f1990 = readerSchema.getField("F199").schema(); + this.f2000 = readerSchema.getField("F200").schema(); + this.f2010 = readerSchema.getField("F201").schema(); + this.f2020 = readerSchema.getField("F202").schema(); + this.f2030 = readerSchema.getField("F203").schema(); + this.f2040 = readerSchema.getField("F204").schema(); + this.f2050 = readerSchema.getField("F205").schema(); + this.f2060 = readerSchema.getField("F206").schema(); + this.f2070 = readerSchema.getField("F207").schema(); + this.f2080 = readerSchema.getField("F208").schema(); + this.f2090 = readerSchema.getField("F209").schema(); + this.f2100 = readerSchema.getField("F210").schema(); + this.f2110 = readerSchema.getField("F211").schema(); + this.f2120 = readerSchema.getField("F212").schema(); + this.f2130 = readerSchema.getField("F213").schema(); + this.f2140 = readerSchema.getField("F214").schema(); + this.f2150 = readerSchema.getField("F215").schema(); + this.f2160 = readerSchema.getField("F216").schema(); + this.f2170 = readerSchema.getField("F217").schema(); + this.f2180 = readerSchema.getField("F218").schema(); + this.f2190 = readerSchema.getField("F219").schema(); + this.f2200 = readerSchema.getField("F220").schema(); + this.f2210 = readerSchema.getField("F221").schema(); + this.f2220 = readerSchema.getField("F222").schema(); + this.f2230 = readerSchema.getField("F223").schema(); + this.f2240 = readerSchema.getField("F224").schema(); + this.f2250 = readerSchema.getField("F225").schema(); + this.f2260 = readerSchema.getField("F226").schema(); + this.f2270 = readerSchema.getField("F227").schema(); + this.f2280 = readerSchema.getField("F228").schema(); + this.f2290 = readerSchema.getField("F229").schema(); + this.f2300 = readerSchema.getField("F230").schema(); + this.f2310 = readerSchema.getField("F231").schema(); + this.f2320 = readerSchema.getField("F232").schema(); + this.f2330 = readerSchema.getField("F233").schema(); + this.f2340 = readerSchema.getField("F234").schema(); + this.f2350 = readerSchema.getField("F235").schema(); + this.f2360 = readerSchema.getField("F236").schema(); + this.f2370 = readerSchema.getField("F237").schema(); + this.f2380 = readerSchema.getField("F238").schema(); + this.f2390 = readerSchema.getField("F239").schema(); + this.f2400 = readerSchema.getField("F240").schema(); + this.f2410 = readerSchema.getField("F241").schema(); + this.f2420 = readerSchema.getField("F242").schema(); + this.f2430 = readerSchema.getField("F243").schema(); + this.f2440 = readerSchema.getField("F244").schema(); + this.f2450 = readerSchema.getField("F245").schema(); + this.f2460 = readerSchema.getField("F246").schema(); + this.f2470 = readerSchema.getField("F247").schema(); + this.f2480 = readerSchema.getField("F248").schema(); + this.f2490 = readerSchema.getField("F249").schema(); + this.f2500 = readerSchema.getField("F250").schema(); + this.f2510 = readerSchema.getField("F251").schema(); + this.f2520 = readerSchema.getField("F252").schema(); + this.f2530 = readerSchema.getField("F253").schema(); + this.f2540 = readerSchema.getField("F254").schema(); + this.f2550 = readerSchema.getField("F255").schema(); + this.f2560 = readerSchema.getField("F256").schema(); + this.f2570 = readerSchema.getField("F257").schema(); + this.f2580 = readerSchema.getField("F258").schema(); + this.f2590 = readerSchema.getField("F259").schema(); + this.f2600 = readerSchema.getField("F260").schema(); + this.f2610 = readerSchema.getField("F261").schema(); + this.f2620 = readerSchema.getField("F262").schema(); + this.f2630 = readerSchema.getField("F263").schema(); + this.f2640 = readerSchema.getField("F264").schema(); + this.f2650 = readerSchema.getField("F265").schema(); + this.f2660 = readerSchema.getField("F266").schema(); + this.f2670 = readerSchema.getField("F267").schema(); + this.f2680 = readerSchema.getField("F268").schema(); + this.f2690 = readerSchema.getField("F269").schema(); + this.f2700 = readerSchema.getField("F270").schema(); + this.f2710 = readerSchema.getField("F271").schema(); + this.f2720 = readerSchema.getField("F272").schema(); + this.f2730 = readerSchema.getField("F273").schema(); + this.f2740 = readerSchema.getField("F274").schema(); + this.f2750 = readerSchema.getField("F275").schema(); + this.f2760 = readerSchema.getField("F276").schema(); + this.f2770 = readerSchema.getField("F277").schema(); + this.f2780 = readerSchema.getField("F278").schema(); + this.f2790 = readerSchema.getField("F279").schema(); + this.f2800 = readerSchema.getField("F280").schema(); + this.f2810 = readerSchema.getField("F281").schema(); + this.f2820 = readerSchema.getField("F282").schema(); + this.f2830 = readerSchema.getField("F283").schema(); + this.f2840 = readerSchema.getField("F284").schema(); + this.f2850 = readerSchema.getField("F285").schema(); + this.f2860 = readerSchema.getField("F286").schema(); + this.f2870 = readerSchema.getField("F287").schema(); + this.f2880 = readerSchema.getField("F288").schema(); + this.f2890 = readerSchema.getField("F289").schema(); + this.f2900 = readerSchema.getField("F290").schema(); + this.f2910 = readerSchema.getField("F291").schema(); + this.f2920 = readerSchema.getField("F292").schema(); + this.f2930 = readerSchema.getField("F293").schema(); + this.f2940 = readerSchema.getField("F294").schema(); + this.f2950 = readerSchema.getField("F295").schema(); + this.f2960 = readerSchema.getField("F296").schema(); + this.f2970 = readerSchema.getField("F297").schema(); + this.f2980 = readerSchema.getField("F298").schema(); + this.f2990 = readerSchema.getField("F299").schema(); + this.f3000 = readerSchema.getField("F300").schema(); + this.f3010 = readerSchema.getField("F301").schema(); + this.f3020 = readerSchema.getField("F302").schema(); + this.f3030 = readerSchema.getField("F303").schema(); + this.f3040 = readerSchema.getField("F304").schema(); + this.f3050 = readerSchema.getField("F305").schema(); + this.f3060 = readerSchema.getField("F306").schema(); + this.f3070 = readerSchema.getField("F307").schema(); + this.f3080 = readerSchema.getField("F308").schema(); + this.f3090 = readerSchema.getField("F309").schema(); + this.f3100 = readerSchema.getField("F310").schema(); + this.f3110 = readerSchema.getField("F311").schema(); + this.f3120 = readerSchema.getField("F312").schema(); + this.f3130 = readerSchema.getField("F313").schema(); + this.f3140 = readerSchema.getField("F314").schema(); + this.f3150 = readerSchema.getField("F315").schema(); + this.f3160 = readerSchema.getField("F316").schema(); + this.f3170 = readerSchema.getField("F317").schema(); + this.f3180 = readerSchema.getField("F318").schema(); + this.f3190 = readerSchema.getField("F319").schema(); + this.f3200 = readerSchema.getField("F320").schema(); + this.f3210 = readerSchema.getField("F321").schema(); + this.f3220 = readerSchema.getField("F322").schema(); + this.f3230 = readerSchema.getField("F323").schema(); + this.f3240 = readerSchema.getField("F324").schema(); + this.f3250 = readerSchema.getField("F325").schema(); + this.f3260 = readerSchema.getField("F326").schema(); + this.f3270 = readerSchema.getField("F327").schema(); + this.f3280 = readerSchema.getField("F328").schema(); + this.f3290 = readerSchema.getField("F329").schema(); + this.f3300 = readerSchema.getField("F330").schema(); + this.f3310 = readerSchema.getField("F331").schema(); + this.f3320 = readerSchema.getField("F332").schema(); + this.f3330 = readerSchema.getField("F333").schema(); + this.f3340 = readerSchema.getField("F334").schema(); + this.f3350 = readerSchema.getField("F335").schema(); + this.f3360 = readerSchema.getField("F336").schema(); + this.f3370 = readerSchema.getField("F337").schema(); + this.f3380 = readerSchema.getField("F338").schema(); + this.f3390 = readerSchema.getField("F339").schema(); + this.f3400 = readerSchema.getField("F340").schema(); + this.f3410 = readerSchema.getField("F341").schema(); + this.f3420 = readerSchema.getField("F342").schema(); + this.f3430 = readerSchema.getField("F343").schema(); + this.f3440 = readerSchema.getField("F344").schema(); + this.f3450 = readerSchema.getField("F345").schema(); + this.f3460 = readerSchema.getField("F346").schema(); + this.f3470 = readerSchema.getField("F347").schema(); + this.f3480 = readerSchema.getField("F348").schema(); + this.f3490 = readerSchema.getField("F349").schema(); + this.f3500 = readerSchema.getField("F350").schema(); + this.f3510 = readerSchema.getField("F351").schema(); + this.f3520 = readerSchema.getField("F352").schema(); + this.f3530 = readerSchema.getField("F353").schema(); + this.f3540 = readerSchema.getField("F354").schema(); + this.f3550 = readerSchema.getField("F355").schema(); + this.f3560 = readerSchema.getField("F356").schema(); + this.f3570 = readerSchema.getField("F357").schema(); + this.f3580 = readerSchema.getField("F358").schema(); + this.f3590 = readerSchema.getField("F359").schema(); + this.f3600 = readerSchema.getField("F360").schema(); + this.f3610 = readerSchema.getField("F361").schema(); + this.f3620 = readerSchema.getField("F362").schema(); + this.f3630 = readerSchema.getField("F363").schema(); + this.f3640 = readerSchema.getField("F364").schema(); + this.f3650 = readerSchema.getField("F365").schema(); + this.f3660 = readerSchema.getField("F366").schema(); + this.f3670 = readerSchema.getField("F367").schema(); + this.f3680 = readerSchema.getField("F368").schema(); + this.f3690 = readerSchema.getField("F369").schema(); + this.f3700 = readerSchema.getField("F370").schema(); + this.f3710 = readerSchema.getField("F371").schema(); + this.f3720 = readerSchema.getField("F372").schema(); + this.f3730 = readerSchema.getField("F373").schema(); + this.f3740 = readerSchema.getField("F374").schema(); + this.f3750 = readerSchema.getField("F375").schema(); + this.f3760 = readerSchema.getField("F376").schema(); + this.f3770 = readerSchema.getField("F377").schema(); + this.f3780 = readerSchema.getField("F378").schema(); + this.f3790 = readerSchema.getField("F379").schema(); + this.f3800 = readerSchema.getField("F380").schema(); + this.f3810 = readerSchema.getField("F381").schema(); + this.f3820 = readerSchema.getField("F382").schema(); + this.f3830 = readerSchema.getField("F383").schema(); + this.f3840 = readerSchema.getField("F384").schema(); + this.f3850 = readerSchema.getField("F385").schema(); + this.f3860 = readerSchema.getField("F386").schema(); + this.f3870 = readerSchema.getField("F387").schema(); + this.f3880 = readerSchema.getField("F388").schema(); + this.f3890 = readerSchema.getField("F389").schema(); + this.f3900 = readerSchema.getField("F390").schema(); + this.f3910 = readerSchema.getField("F391").schema(); + this.f3920 = readerSchema.getField("F392").schema(); + this.f3930 = readerSchema.getField("F393").schema(); + this.f3940 = readerSchema.getField("F394").schema(); + this.f3950 = readerSchema.getField("F395").schema(); + this.f3960 = readerSchema.getField("F396").schema(); + this.f3970 = readerSchema.getField("F397").schema(); + this.f3980 = readerSchema.getField("F398").schema(); + this.f3990 = readerSchema.getField("F399").schema(); + this.f4000 = readerSchema.getField("F400").schema(); + this.f4010 = readerSchema.getField("F401").schema(); + this.f4020 = readerSchema.getField("F402").schema(); + this.f4030 = readerSchema.getField("F403").schema(); + this.f4040 = readerSchema.getField("F404").schema(); + this.f4050 = readerSchema.getField("F405").schema(); + this.f4060 = readerSchema.getField("F406").schema(); + this.f4070 = readerSchema.getField("F407").schema(); + this.f4080 = readerSchema.getField("F408").schema(); + this.f4090 = readerSchema.getField("F409").schema(); + this.f4100 = readerSchema.getField("F410").schema(); + this.f4110 = readerSchema.getField("F411").schema(); + this.f4120 = readerSchema.getField("F412").schema(); + this.f4130 = readerSchema.getField("F413").schema(); + this.f4140 = readerSchema.getField("F414").schema(); + this.f4150 = readerSchema.getField("F415").schema(); + this.f4160 = readerSchema.getField("F416").schema(); + this.f4170 = readerSchema.getField("F417").schema(); + this.f4180 = readerSchema.getField("F418").schema(); + this.f4190 = readerSchema.getField("F419").schema(); + this.f4200 = readerSchema.getField("F420").schema(); + this.f4210 = readerSchema.getField("F421").schema(); + this.f4220 = readerSchema.getField("F422").schema(); + this.f4230 = readerSchema.getField("F423").schema(); + this.f4240 = readerSchema.getField("F424").schema(); + this.f4250 = readerSchema.getField("F425").schema(); + this.f4260 = readerSchema.getField("F426").schema(); + this.f4270 = readerSchema.getField("F427").schema(); + this.f4280 = readerSchema.getField("F428").schema(); + this.f4290 = readerSchema.getField("F429").schema(); + this.f4300 = readerSchema.getField("F430").schema(); + this.f4310 = readerSchema.getField("F431").schema(); + this.f4320 = readerSchema.getField("F432").schema(); + this.f4330 = readerSchema.getField("F433").schema(); + this.f4340 = readerSchema.getField("F434").schema(); + this.f4350 = readerSchema.getField("F435").schema(); + this.f4360 = readerSchema.getField("F436").schema(); + this.f4370 = readerSchema.getField("F437").schema(); + this.f4380 = readerSchema.getField("F438").schema(); + this.f4390 = readerSchema.getField("F439").schema(); + this.f4400 = readerSchema.getField("F440").schema(); + this.f4410 = readerSchema.getField("F441").schema(); + this.f4420 = readerSchema.getField("F442").schema(); + this.f4430 = readerSchema.getField("F443").schema(); + this.f4440 = readerSchema.getField("F444").schema(); + this.f4450 = readerSchema.getField("F445").schema(); + this.f4460 = readerSchema.getField("F446").schema(); + this.f4470 = readerSchema.getField("F447").schema(); + this.f4480 = readerSchema.getField("F448").schema(); + this.f4490 = readerSchema.getField("F449").schema(); + this.f4500 = readerSchema.getField("F450").schema(); + this.f4510 = readerSchema.getField("F451").schema(); + this.f4520 = readerSchema.getField("F452").schema(); + this.f4530 = readerSchema.getField("F453").schema(); + this.f4540 = readerSchema.getField("F454").schema(); + this.f4550 = readerSchema.getField("F455").schema(); + this.f4560 = readerSchema.getField("F456").schema(); + this.f4570 = readerSchema.getField("F457").schema(); + this.f4580 = readerSchema.getField("F458").schema(); + this.f4590 = readerSchema.getField("F459").schema(); + this.f4600 = readerSchema.getField("F460").schema(); + this.f4610 = readerSchema.getField("F461").schema(); + this.f4620 = readerSchema.getField("F462").schema(); + this.f4630 = readerSchema.getField("F463").schema(); + this.f4640 = readerSchema.getField("F464").schema(); + this.f4650 = readerSchema.getField("F465").schema(); + this.f4660 = readerSchema.getField("F466").schema(); + this.f4670 = readerSchema.getField("F467").schema(); + this.f4680 = readerSchema.getField("F468").schema(); + this.f4690 = readerSchema.getField("F469").schema(); + this.f4700 = readerSchema.getField("F470").schema(); + this.f4710 = readerSchema.getField("F471").schema(); + this.f4720 = readerSchema.getField("F472").schema(); + this.f4730 = readerSchema.getField("F473").schema(); + this.f4740 = readerSchema.getField("F474").schema(); + this.f4750 = readerSchema.getField("F475").schema(); + this.f4760 = readerSchema.getField("F476").schema(); + this.f4770 = readerSchema.getField("F477").schema(); + this.f4780 = readerSchema.getField("F478").schema(); + this.f4790 = readerSchema.getField("F479").schema(); + this.f4800 = readerSchema.getField("F480").schema(); + this.f4810 = readerSchema.getField("F481").schema(); + this.f4820 = readerSchema.getField("F482").schema(); + this.f4830 = readerSchema.getField("F483").schema(); + this.f4840 = readerSchema.getField("F484").schema(); + this.f4850 = readerSchema.getField("F485").schema(); + this.f4860 = readerSchema.getField("F486").schema(); + this.f4870 = readerSchema.getField("F487").schema(); + this.f4880 = readerSchema.getField("F488").schema(); + this.f4890 = readerSchema.getField("F489").schema(); + this.f4900 = readerSchema.getField("F490").schema(); + this.f4910 = readerSchema.getField("F491").schema(); + this.f4920 = readerSchema.getField("F492").schema(); + this.f4930 = readerSchema.getField("F493").schema(); + this.f4940 = readerSchema.getField("F494").schema(); + this.f4950 = readerSchema.getField("F495").schema(); + this.f4960 = readerSchema.getField("F496").schema(); + this.f4970 = readerSchema.getField("F497").schema(); + this.f4980 = readerSchema.getField("F498").schema(); + this.f4990 = readerSchema.getField("F499").schema(); + this.f5000 = readerSchema.getField("F500").schema(); + this.f5010 = readerSchema.getField("F501").schema(); + this.f5020 = readerSchema.getField("F502").schema(); + this.f5030 = readerSchema.getField("F503").schema(); + this.f5040 = readerSchema.getField("F504").schema(); + this.f5050 = readerSchema.getField("F505").schema(); + this.f5060 = readerSchema.getField("F506").schema(); + this.f5070 = readerSchema.getField("F507").schema(); + this.f5080 = readerSchema.getField("F508").schema(); + this.f5090 = readerSchema.getField("F509").schema(); + this.f5100 = readerSchema.getField("F510").schema(); + this.f5110 = readerSchema.getField("F511").schema(); + this.f5120 = readerSchema.getField("F512").schema(); + this.f5130 = readerSchema.getField("F513").schema(); + this.f5140 = readerSchema.getField("F514").schema(); + this.f5150 = readerSchema.getField("F515").schema(); + this.f5160 = readerSchema.getField("F516").schema(); + this.f5170 = readerSchema.getField("F517").schema(); + this.f5180 = readerSchema.getField("F518").schema(); + this.f5190 = readerSchema.getField("F519").schema(); + this.f5200 = readerSchema.getField("F520").schema(); + this.f5210 = readerSchema.getField("F521").schema(); + this.f5220 = readerSchema.getField("F522").schema(); + this.f5230 = readerSchema.getField("F523").schema(); + this.f5240 = readerSchema.getField("F524").schema(); + this.f5250 = readerSchema.getField("F525").schema(); + this.f5260 = readerSchema.getField("F526").schema(); + this.f5270 = readerSchema.getField("F527").schema(); + this.f5280 = readerSchema.getField("F528").schema(); + this.f5290 = readerSchema.getField("F529").schema(); + this.f5300 = readerSchema.getField("F530").schema(); + this.f5310 = readerSchema.getField("F531").schema(); + this.f5320 = readerSchema.getField("F532").schema(); + this.f5330 = readerSchema.getField("F533").schema(); + this.f5340 = readerSchema.getField("F534").schema(); + this.f5350 = readerSchema.getField("F535").schema(); + this.f5360 = readerSchema.getField("F536").schema(); + this.f5370 = readerSchema.getField("F537").schema(); + this.f5380 = readerSchema.getField("F538").schema(); + this.f5390 = readerSchema.getField("F539").schema(); + this.f5400 = readerSchema.getField("F540").schema(); + this.f5410 = readerSchema.getField("F541").schema(); + this.f5420 = readerSchema.getField("F542").schema(); + this.f5430 = readerSchema.getField("F543").schema(); + this.f5440 = readerSchema.getField("F544").schema(); + this.f5450 = readerSchema.getField("F545").schema(); + this.f5460 = readerSchema.getField("F546").schema(); + this.f5470 = readerSchema.getField("F547").schema(); + this.f5480 = readerSchema.getField("F548").schema(); + this.f5490 = readerSchema.getField("F549").schema(); + this.f5500 = readerSchema.getField("F550").schema(); + this.f5510 = readerSchema.getField("F551").schema(); + this.f5520 = readerSchema.getField("F552").schema(); + this.f5530 = readerSchema.getField("F553").schema(); + this.f5540 = readerSchema.getField("F554").schema(); + this.f5550 = readerSchema.getField("F555").schema(); + this.f5560 = readerSchema.getField("F556").schema(); + this.f5570 = readerSchema.getField("F557").schema(); + this.f5580 = readerSchema.getField("F558").schema(); + this.f5590 = readerSchema.getField("F559").schema(); + this.f5600 = readerSchema.getField("F560").schema(); + this.f5610 = readerSchema.getField("F561").schema(); + this.f5620 = readerSchema.getField("F562").schema(); + this.f5630 = readerSchema.getField("F563").schema(); + this.f5640 = readerSchema.getField("F564").schema(); + this.f5650 = readerSchema.getField("F565").schema(); + this.f5660 = readerSchema.getField("F566").schema(); + this.f5670 = readerSchema.getField("F567").schema(); + this.f5680 = readerSchema.getField("F568").schema(); + this.f5690 = readerSchema.getField("F569").schema(); + this.f5700 = readerSchema.getField("F570").schema(); + this.f5710 = readerSchema.getField("F571").schema(); + this.f5720 = readerSchema.getField("F572").schema(); + this.f5730 = readerSchema.getField("F573").schema(); + this.f5740 = readerSchema.getField("F574").schema(); + this.f5750 = readerSchema.getField("F575").schema(); + this.f5760 = readerSchema.getField("F576").schema(); + this.f5770 = readerSchema.getField("F577").schema(); + this.f5780 = readerSchema.getField("F578").schema(); + this.f5790 = readerSchema.getField("F579").schema(); + this.f5800 = readerSchema.getField("F580").schema(); + this.f5810 = readerSchema.getField("F581").schema(); + this.f5820 = readerSchema.getField("F582").schema(); + this.f5830 = readerSchema.getField("F583").schema(); + this.f5840 = readerSchema.getField("F584").schema(); + this.f5850 = readerSchema.getField("F585").schema(); + this.f5860 = readerSchema.getField("F586").schema(); + this.f5870 = readerSchema.getField("F587").schema(); + this.f5880 = readerSchema.getField("F588").schema(); + this.f5890 = readerSchema.getField("F589").schema(); + this.f5900 = readerSchema.getField("F590").schema(); + this.f5910 = readerSchema.getField("F591").schema(); + this.f5920 = readerSchema.getField("F592").schema(); + this.f5930 = readerSchema.getField("F593").schema(); + this.f5940 = readerSchema.getField("F594").schema(); + this.f5950 = readerSchema.getField("F595").schema(); + this.f5960 = readerSchema.getField("F596").schema(); + this.f5970 = readerSchema.getField("F597").schema(); + this.f5980 = readerSchema.getField("F598").schema(); + this.f5990 = readerSchema.getField("F599").schema(); + this.f6000 = readerSchema.getField("F600").schema(); + this.f6010 = readerSchema.getField("F601").schema(); + this.f6020 = readerSchema.getField("F602").schema(); + this.f6030 = readerSchema.getField("F603").schema(); + this.f6040 = readerSchema.getField("F604").schema(); + this.f6050 = readerSchema.getField("F605").schema(); + this.f6060 = readerSchema.getField("F606").schema(); + this.f6070 = readerSchema.getField("F607").schema(); + this.f6080 = readerSchema.getField("F608").schema(); + this.f6090 = readerSchema.getField("F609").schema(); + this.f6100 = readerSchema.getField("F610").schema(); + this.f6110 = readerSchema.getField("F611").schema(); + this.f6120 = readerSchema.getField("F612").schema(); + this.f6130 = readerSchema.getField("F613").schema(); + this.f6140 = readerSchema.getField("F614").schema(); + this.f6150 = readerSchema.getField("F615").schema(); + this.f6160 = readerSchema.getField("F616").schema(); + this.f6170 = readerSchema.getField("F617").schema(); + this.f6180 = readerSchema.getField("F618").schema(); + this.f6190 = readerSchema.getField("F619").schema(); + this.f6200 = readerSchema.getField("F620").schema(); + this.f6210 = readerSchema.getField("F621").schema(); + this.f6220 = readerSchema.getField("F622").schema(); + this.f6230 = readerSchema.getField("F623").schema(); + this.f6240 = readerSchema.getField("F624").schema(); + this.f6250 = readerSchema.getField("F625").schema(); + this.f6260 = readerSchema.getField("F626").schema(); + this.f6270 = readerSchema.getField("F627").schema(); + this.f6280 = readerSchema.getField("F628").schema(); + this.f6290 = readerSchema.getField("F629").schema(); + this.f6300 = readerSchema.getField("F630").schema(); + this.f6310 = readerSchema.getField("F631").schema(); + this.f6320 = readerSchema.getField("F632").schema(); + this.f6330 = readerSchema.getField("F633").schema(); + this.f6340 = readerSchema.getField("F634").schema(); + this.f6350 = readerSchema.getField("F635").schema(); + this.f6360 = readerSchema.getField("F636").schema(); + this.f6370 = readerSchema.getField("F637").schema(); + this.f6380 = readerSchema.getField("F638").schema(); + this.f6390 = readerSchema.getField("F639").schema(); + this.f6400 = readerSchema.getField("F640").schema(); + this.f6410 = readerSchema.getField("F641").schema(); + this.f6420 = readerSchema.getField("F642").schema(); + this.f6430 = readerSchema.getField("F643").schema(); + this.f6440 = readerSchema.getField("F644").schema(); + this.f6450 = readerSchema.getField("F645").schema(); + this.f6460 = readerSchema.getField("F646").schema(); + this.f6470 = readerSchema.getField("F647").schema(); + this.f6480 = readerSchema.getField("F648").schema(); + this.f6490 = readerSchema.getField("F649").schema(); + this.f6500 = readerSchema.getField("F650").schema(); + this.f6510 = readerSchema.getField("F651").schema(); + this.f6520 = readerSchema.getField("F652").schema(); + this.f6530 = readerSchema.getField("F653").schema(); + this.f6540 = readerSchema.getField("F654").schema(); + this.f6550 = readerSchema.getField("F655").schema(); + this.f6560 = readerSchema.getField("F656").schema(); + this.f6570 = readerSchema.getField("F657").schema(); + this.f6580 = readerSchema.getField("F658").schema(); + this.f6590 = readerSchema.getField("F659").schema(); + this.f6600 = readerSchema.getField("F660").schema(); + this.f6610 = readerSchema.getField("F661").schema(); + this.f6620 = readerSchema.getField("F662").schema(); + this.f6630 = readerSchema.getField("F663").schema(); + this.f6640 = readerSchema.getField("F664").schema(); + this.f6650 = readerSchema.getField("F665").schema(); + this.f6660 = readerSchema.getField("F666").schema(); + this.f6670 = readerSchema.getField("F667").schema(); + this.f6680 = readerSchema.getField("F668").schema(); + this.f6690 = readerSchema.getField("F669").schema(); + this.f6700 = readerSchema.getField("F670").schema(); + this.f6710 = readerSchema.getField("F671").schema(); + this.f6720 = readerSchema.getField("F672").schema(); + this.f6730 = readerSchema.getField("F673").schema(); + this.f6740 = readerSchema.getField("F674").schema(); + this.f6750 = readerSchema.getField("F675").schema(); + this.f6760 = readerSchema.getField("F676").schema(); + this.f6770 = readerSchema.getField("F677").schema(); + this.f6780 = readerSchema.getField("F678").schema(); + this.f6790 = readerSchema.getField("F679").schema(); + this.f6800 = readerSchema.getField("F680").schema(); + this.f6810 = readerSchema.getField("F681").schema(); + this.f6820 = readerSchema.getField("F682").schema(); + this.f6830 = readerSchema.getField("F683").schema(); + this.f6840 = readerSchema.getField("F684").schema(); + this.f6850 = readerSchema.getField("F685").schema(); + this.f6860 = readerSchema.getField("F686").schema(); + this.f6870 = readerSchema.getField("F687").schema(); + this.f6880 = readerSchema.getField("F688").schema(); + this.f6890 = readerSchema.getField("F689").schema(); + this.f6900 = readerSchema.getField("F690").schema(); + this.f6910 = readerSchema.getField("F691").schema(); + this.f6920 = readerSchema.getField("F692").schema(); + this.f6930 = readerSchema.getField("F693").schema(); + this.f6940 = readerSchema.getField("F694").schema(); + this.f6950 = readerSchema.getField("F695").schema(); + this.f6960 = readerSchema.getField("F696").schema(); + this.f6970 = readerSchema.getField("F697").schema(); + this.f6980 = readerSchema.getField("F698").schema(); + this.f6990 = readerSchema.getField("F699").schema(); + this.f7000 = readerSchema.getField("F700").schema(); + this.f7010 = readerSchema.getField("F701").schema(); + this.f7020 = readerSchema.getField("F702").schema(); + this.f7030 = readerSchema.getField("F703").schema(); + this.f7040 = readerSchema.getField("F704").schema(); + this.f7050 = readerSchema.getField("F705").schema(); + this.f7060 = readerSchema.getField("F706").schema(); + this.f7070 = readerSchema.getField("F707").schema(); + this.f7080 = readerSchema.getField("F708").schema(); + this.f7090 = readerSchema.getField("F709").schema(); + this.f7100 = readerSchema.getField("F710").schema(); + this.f7110 = readerSchema.getField("F711").schema(); + this.f7120 = readerSchema.getField("F712").schema(); + this.f7130 = readerSchema.getField("F713").schema(); + this.f7140 = readerSchema.getField("F714").schema(); + this.f7150 = readerSchema.getField("F715").schema(); + this.f7160 = readerSchema.getField("F716").schema(); + this.f7170 = readerSchema.getField("F717").schema(); + this.f7180 = readerSchema.getField("F718").schema(); + this.f7190 = readerSchema.getField("F719").schema(); + this.f7200 = readerSchema.getField("F720").schema(); + this.f7210 = readerSchema.getField("F721").schema(); + this.f7220 = readerSchema.getField("F722").schema(); + this.f7230 = readerSchema.getField("F723").schema(); + this.f7240 = readerSchema.getField("F724").schema(); + this.f7250 = readerSchema.getField("F725").schema(); + this.f7260 = readerSchema.getField("F726").schema(); + this.f7270 = readerSchema.getField("F727").schema(); + this.f7280 = readerSchema.getField("F728").schema(); + this.f7290 = readerSchema.getField("F729").schema(); + this.f7300 = readerSchema.getField("F730").schema(); + this.f7310 = readerSchema.getField("F731").schema(); + this.f7320 = readerSchema.getField("F732").schema(); + this.f7330 = readerSchema.getField("F733").schema(); + this.f7340 = readerSchema.getField("F734").schema(); + this.f7350 = readerSchema.getField("F735").schema(); + this.f7360 = readerSchema.getField("F736").schema(); + this.f7370 = readerSchema.getField("F737").schema(); + this.f7380 = readerSchema.getField("F738").schema(); + this.f7390 = readerSchema.getField("F739").schema(); + this.f7400 = readerSchema.getField("F740").schema(); + this.f7410 = readerSchema.getField("F741").schema(); + this.f7420 = readerSchema.getField("F742").schema(); + this.f7430 = readerSchema.getField("F743").schema(); + this.f7440 = readerSchema.getField("F744").schema(); + this.f7450 = readerSchema.getField("F745").schema(); + this.f7460 = readerSchema.getField("F746").schema(); + this.f7470 = readerSchema.getField("F747").schema(); + this.f7480 = readerSchema.getField("F748").schema(); + this.f7490 = readerSchema.getField("F749").schema(); + this.f7500 = readerSchema.getField("F750").schema(); + this.f7510 = readerSchema.getField("F751").schema(); + this.f7520 = readerSchema.getField("F752").schema(); + this.f7530 = readerSchema.getField("F753").schema(); + this.f7540 = readerSchema.getField("F754").schema(); + this.f7550 = readerSchema.getField("F755").schema(); + this.f7560 = readerSchema.getField("F756").schema(); + this.f7570 = readerSchema.getField("F757").schema(); + this.f7580 = readerSchema.getField("F758").schema(); + this.f7590 = readerSchema.getField("F759").schema(); + this.f7600 = readerSchema.getField("F760").schema(); + this.f7610 = readerSchema.getField("F761").schema(); + this.f7620 = readerSchema.getField("F762").schema(); + this.f7630 = readerSchema.getField("F763").schema(); + this.f7640 = readerSchema.getField("F764").schema(); + this.f7650 = readerSchema.getField("F765").schema(); + this.f7660 = readerSchema.getField("F766").schema(); + this.f7670 = readerSchema.getField("F767").schema(); + this.f7680 = readerSchema.getField("F768").schema(); + this.f7690 = readerSchema.getField("F769").schema(); + this.f7700 = readerSchema.getField("F770").schema(); + this.f7710 = readerSchema.getField("F771").schema(); + this.f7720 = readerSchema.getField("F772").schema(); + this.f7730 = readerSchema.getField("F773").schema(); + this.f7740 = readerSchema.getField("F774").schema(); + this.f7750 = readerSchema.getField("F775").schema(); + this.f7760 = readerSchema.getField("F776").schema(); + this.f7770 = readerSchema.getField("F777").schema(); + this.f7780 = readerSchema.getField("F778").schema(); + this.f7790 = readerSchema.getField("F779").schema(); + this.f7800 = readerSchema.getField("F780").schema(); + this.f7810 = readerSchema.getField("F781").schema(); + this.f7820 = readerSchema.getField("F782").schema(); + this.f7830 = readerSchema.getField("F783").schema(); + this.f7840 = readerSchema.getField("F784").schema(); + this.f7850 = readerSchema.getField("F785").schema(); + this.f7860 = readerSchema.getField("F786").schema(); + this.f7870 = readerSchema.getField("F787").schema(); + this.f7880 = readerSchema.getField("F788").schema(); + this.f7890 = readerSchema.getField("F789").schema(); + this.f7900 = readerSchema.getField("F790").schema(); + this.f7910 = readerSchema.getField("F791").schema(); + this.f7920 = readerSchema.getField("F792").schema(); + this.f7930 = readerSchema.getField("F793").schema(); + this.f7940 = readerSchema.getField("F794").schema(); + this.f7950 = readerSchema.getField("F795").schema(); + this.f7960 = readerSchema.getField("F796").schema(); + this.f7970 = readerSchema.getField("F797").schema(); + this.f7980 = readerSchema.getField("F798").schema(); + this.f7990 = readerSchema.getField("F799").schema(); + this.f8000 = readerSchema.getField("F800").schema(); + this.f8010 = readerSchema.getField("F801").schema(); + this.f8020 = readerSchema.getField("F802").schema(); + this.f8030 = readerSchema.getField("F803").schema(); + this.f8040 = readerSchema.getField("F804").schema(); + this.f8050 = readerSchema.getField("F805").schema(); + this.f8060 = readerSchema.getField("F806").schema(); + this.f8070 = readerSchema.getField("F807").schema(); + this.f8080 = readerSchema.getField("F808").schema(); + this.f8090 = readerSchema.getField("F809").schema(); + this.f8100 = readerSchema.getField("F810").schema(); + this.f8110 = readerSchema.getField("F811").schema(); + this.f8120 = readerSchema.getField("F812").schema(); + this.f8130 = readerSchema.getField("F813").schema(); + this.f8140 = readerSchema.getField("F814").schema(); + this.f8150 = readerSchema.getField("F815").schema(); + this.f8160 = readerSchema.getField("F816").schema(); + this.f8170 = readerSchema.getField("F817").schema(); + this.f8180 = readerSchema.getField("F818").schema(); + this.f8190 = readerSchema.getField("F819").schema(); + this.f8200 = readerSchema.getField("F820").schema(); + this.f8210 = readerSchema.getField("F821").schema(); + this.f8220 = readerSchema.getField("F822").schema(); + this.f8230 = readerSchema.getField("F823").schema(); + this.f8240 = readerSchema.getField("F824").schema(); + this.f8250 = readerSchema.getField("F825").schema(); + this.f8260 = readerSchema.getField("F826").schema(); + this.f8270 = readerSchema.getField("F827").schema(); + this.f8280 = readerSchema.getField("F828").schema(); + this.f8290 = readerSchema.getField("F829").schema(); + this.f8300 = readerSchema.getField("F830").schema(); + this.f8310 = readerSchema.getField("F831").schema(); + this.f8320 = readerSchema.getField("F832").schema(); + this.f8330 = readerSchema.getField("F833").schema(); + this.f8340 = readerSchema.getField("F834").schema(); + this.f8350 = readerSchema.getField("F835").schema(); + this.f8360 = readerSchema.getField("F836").schema(); + this.f8370 = readerSchema.getField("F837").schema(); + this.f8380 = readerSchema.getField("F838").schema(); + this.f8390 = readerSchema.getField("F839").schema(); + this.f8400 = readerSchema.getField("F840").schema(); + this.f8410 = readerSchema.getField("F841").schema(); + this.f8420 = readerSchema.getField("F842").schema(); + this.f8430 = readerSchema.getField("F843").schema(); + this.f8440 = readerSchema.getField("F844").schema(); + this.f8450 = readerSchema.getField("F845").schema(); + this.f8460 = readerSchema.getField("F846").schema(); + this.f8470 = readerSchema.getField("F847").schema(); + this.f8480 = readerSchema.getField("F848").schema(); + this.f8490 = readerSchema.getField("F849").schema(); + this.f8500 = readerSchema.getField("F850").schema(); + this.f8510 = readerSchema.getField("F851").schema(); + this.f8520 = readerSchema.getField("F852").schema(); + this.f8530 = readerSchema.getField("F853").schema(); + this.f8540 = readerSchema.getField("F854").schema(); + this.f8550 = readerSchema.getField("F855").schema(); + this.f8560 = readerSchema.getField("F856").schema(); + this.f8570 = readerSchema.getField("F857").schema(); + this.f8580 = readerSchema.getField("F858").schema(); + this.f8590 = readerSchema.getField("F859").schema(); + this.f8600 = readerSchema.getField("F860").schema(); + this.f8610 = readerSchema.getField("F861").schema(); + this.f8620 = readerSchema.getField("F862").schema(); + this.f8630 = readerSchema.getField("F863").schema(); + this.f8640 = readerSchema.getField("F864").schema(); + this.f8650 = readerSchema.getField("F865").schema(); + this.f8660 = readerSchema.getField("F866").schema(); + this.f8670 = readerSchema.getField("F867").schema(); + this.f8680 = readerSchema.getField("F868").schema(); + this.f8690 = readerSchema.getField("F869").schema(); + this.f8700 = readerSchema.getField("F870").schema(); + this.f8710 = readerSchema.getField("F871").schema(); + this.f8720 = readerSchema.getField("F872").schema(); + this.f8730 = readerSchema.getField("F873").schema(); + this.f8740 = readerSchema.getField("F874").schema(); + this.f8750 = readerSchema.getField("F875").schema(); + this.f8760 = readerSchema.getField("F876").schema(); + this.f8770 = readerSchema.getField("F877").schema(); + this.f8780 = readerSchema.getField("F878").schema(); + this.f8790 = readerSchema.getField("F879").schema(); + this.f8800 = readerSchema.getField("F880").schema(); + this.f8810 = readerSchema.getField("F881").schema(); + this.f8820 = readerSchema.getField("F882").schema(); + this.f8830 = readerSchema.getField("F883").schema(); + this.f8840 = readerSchema.getField("F884").schema(); + this.f8850 = readerSchema.getField("F885").schema(); + this.f8860 = readerSchema.getField("F886").schema(); + this.f8870 = readerSchema.getField("F887").schema(); + this.f8880 = readerSchema.getField("F888").schema(); + this.f8890 = readerSchema.getField("F889").schema(); + this.f8900 = readerSchema.getField("F890").schema(); + this.f8910 = readerSchema.getField("F891").schema(); + this.f8920 = readerSchema.getField("F892").schema(); + this.f8930 = readerSchema.getField("F893").schema(); + this.f8940 = readerSchema.getField("F894").schema(); + this.f8950 = readerSchema.getField("F895").schema(); + this.f8960 = readerSchema.getField("F896").schema(); + this.f8970 = readerSchema.getField("F897").schema(); + this.f8980 = readerSchema.getField("F898").schema(); + this.f8990 = readerSchema.getField("F899").schema(); + this.f9000 = readerSchema.getField("F900").schema(); + this.f9010 = readerSchema.getField("F901").schema(); + this.f9020 = readerSchema.getField("F902").schema(); + this.f9030 = readerSchema.getField("F903").schema(); + this.f9040 = readerSchema.getField("F904").schema(); + this.f9050 = readerSchema.getField("F905").schema(); + this.f9060 = readerSchema.getField("F906").schema(); + this.f9070 = readerSchema.getField("F907").schema(); + this.f9080 = readerSchema.getField("F908").schema(); + this.f9090 = readerSchema.getField("F909").schema(); + this.f9100 = readerSchema.getField("F910").schema(); + this.f9110 = readerSchema.getField("F911").schema(); + this.f9120 = readerSchema.getField("F912").schema(); + this.f9130 = readerSchema.getField("F913").schema(); + this.f9140 = readerSchema.getField("F914").schema(); + this.f9150 = readerSchema.getField("F915").schema(); + this.f9160 = readerSchema.getField("F916").schema(); + this.f9170 = readerSchema.getField("F917").schema(); + this.f9180 = readerSchema.getField("F918").schema(); + this.f9190 = readerSchema.getField("F919").schema(); + this.f9200 = readerSchema.getField("F920").schema(); + this.f9210 = readerSchema.getField("F921").schema(); + this.f9220 = readerSchema.getField("F922").schema(); + this.f9230 = readerSchema.getField("F923").schema(); + this.f9240 = readerSchema.getField("F924").schema(); + this.f9250 = readerSchema.getField("F925").schema(); + this.f9260 = readerSchema.getField("F926").schema(); + this.f9270 = readerSchema.getField("F927").schema(); + this.f9280 = readerSchema.getField("F928").schema(); + this.f9290 = readerSchema.getField("F929").schema(); + this.f9300 = readerSchema.getField("F930").schema(); + this.f9310 = readerSchema.getField("F931").schema(); + this.f9320 = readerSchema.getField("F932").schema(); + this.f9330 = readerSchema.getField("F933").schema(); + this.f9340 = readerSchema.getField("F934").schema(); + this.f9350 = readerSchema.getField("F935").schema(); + this.f9360 = readerSchema.getField("F936").schema(); + this.f9370 = readerSchema.getField("F937").schema(); + this.f9380 = readerSchema.getField("F938").schema(); + this.f9390 = readerSchema.getField("F939").schema(); + this.f9400 = readerSchema.getField("F940").schema(); + this.f9410 = readerSchema.getField("F941").schema(); + this.f9420 = readerSchema.getField("F942").schema(); + this.f9430 = readerSchema.getField("F943").schema(); + this.f9440 = readerSchema.getField("F944").schema(); + this.f9450 = readerSchema.getField("F945").schema(); + this.f9460 = readerSchema.getField("F946").schema(); + this.f9470 = readerSchema.getField("F947").schema(); + this.f9480 = readerSchema.getField("F948").schema(); + this.f9490 = readerSchema.getField("F949").schema(); + this.f9500 = readerSchema.getField("F950").schema(); + this.f9510 = readerSchema.getField("F951").schema(); + this.f9520 = readerSchema.getField("F952").schema(); + this.f9530 = readerSchema.getField("F953").schema(); + this.f9540 = readerSchema.getField("F954").schema(); + this.f9550 = readerSchema.getField("F955").schema(); + this.f9560 = readerSchema.getField("F956").schema(); + this.f9570 = readerSchema.getField("F957").schema(); + this.f9580 = readerSchema.getField("F958").schema(); + this.f9590 = readerSchema.getField("F959").schema(); + this.f9600 = readerSchema.getField("F960").schema(); + this.f9610 = readerSchema.getField("F961").schema(); + this.f9620 = readerSchema.getField("F962").schema(); + this.f9630 = readerSchema.getField("F963").schema(); + this.f9640 = readerSchema.getField("F964").schema(); + this.f9650 = readerSchema.getField("F965").schema(); + this.f9660 = readerSchema.getField("F966").schema(); + this.f9670 = readerSchema.getField("F967").schema(); + this.f9680 = readerSchema.getField("F968").schema(); + this.f9690 = readerSchema.getField("F969").schema(); + this.f9700 = readerSchema.getField("F970").schema(); + this.f9710 = readerSchema.getField("F971").schema(); + this.f9720 = readerSchema.getField("F972").schema(); + this.f9730 = readerSchema.getField("F973").schema(); + this.f9740 = readerSchema.getField("F974").schema(); + this.f9750 = readerSchema.getField("F975").schema(); + this.f9760 = readerSchema.getField("F976").schema(); + this.f9770 = readerSchema.getField("F977").schema(); + this.f9780 = readerSchema.getField("F978").schema(); + this.f9790 = readerSchema.getField("F979").schema(); + this.f9800 = readerSchema.getField("F980").schema(); + this.f9810 = readerSchema.getField("F981").schema(); + this.f9820 = readerSchema.getField("F982").schema(); + this.f9830 = readerSchema.getField("F983").schema(); + this.f9840 = readerSchema.getField("F984").schema(); + this.f9850 = readerSchema.getField("F985").schema(); + this.f9860 = readerSchema.getField("F986").schema(); + this.f9870 = readerSchema.getField("F987").schema(); + this.f9880 = readerSchema.getField("F988").schema(); + this.f9890 = readerSchema.getField("F989").schema(); + this.f9900 = readerSchema.getField("F990").schema(); + this.f9910 = readerSchema.getField("F991").schema(); + this.f9920 = readerSchema.getField("F992").schema(); + this.f9930 = readerSchema.getField("F993").schema(); + this.f9940 = readerSchema.getField("F994").schema(); + this.f9950 = readerSchema.getField("F995").schema(); + this.f9960 = readerSchema.getField("F996").schema(); + this.f9970 = readerSchema.getField("F997").schema(); + this.f9980 = readerSchema.getField("F998").schema(); + this.f9990 = readerSchema.getField("F999").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'F0': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(1, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'F1': "+ unionIndex1)); + } + } + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(2, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence2; + Object oldString2 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(2); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(2, charSequence2); + } else { + throw new RuntimeException(("Illegal union index for 'F2': "+ unionIndex2)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(3, null); + } else { + if (unionIndex3 == 1) { + Utf8 charSequence3; + Object oldString3 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(3); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(3, charSequence3); + } else { + throw new RuntimeException(("Illegal union index for 'F3': "+ unionIndex3)); + } + } + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(4, null); + } else { + if (unionIndex4 == 1) { + Utf8 charSequence4; + Object oldString4 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(4); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(4, charSequence4); + } else { + throw new RuntimeException(("Illegal union index for 'F4': "+ unionIndex4)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(5, null); + } else { + if (unionIndex5 == 1) { + Utf8 charSequence5; + Object oldString5 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(5); + if (oldString5 instanceof Utf8) { + charSequence5 = (decoder).readString(((Utf8) oldString5)); + } else { + charSequence5 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(5, charSequence5); + } else { + throw new RuntimeException(("Illegal union index for 'F5': "+ unionIndex5)); + } + } + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(6, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence6; + Object oldString6 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(6); + if (oldString6 instanceof Utf8) { + charSequence6 = (decoder).readString(((Utf8) oldString6)); + } else { + charSequence6 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(6, charSequence6); + } else { + throw new RuntimeException(("Illegal union index for 'F6': "+ unionIndex6)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(7, null); + } else { + if (unionIndex7 == 1) { + Utf8 charSequence7; + Object oldString7 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(7); + if (oldString7 instanceof Utf8) { + charSequence7 = (decoder).readString(((Utf8) oldString7)); + } else { + charSequence7 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(7, charSequence7); + } else { + throw new RuntimeException(("Illegal union index for 'F7': "+ unionIndex7)); + } + } + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(8, null); + } else { + if (unionIndex8 == 1) { + Utf8 charSequence8; + Object oldString8 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(8); + if (oldString8 instanceof Utf8) { + charSequence8 = (decoder).readString(((Utf8) oldString8)); + } else { + charSequence8 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(8, charSequence8); + } else { + throw new RuntimeException(("Illegal union index for 'F8': "+ unionIndex8)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex9 = (decoder.readIndex()); + if (unionIndex9 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(9, null); + } else { + if (unionIndex9 == 1) { + Utf8 charSequence9; + Object oldString9 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(9); + if (oldString9 instanceof Utf8) { + charSequence9 = (decoder).readString(((Utf8) oldString9)); + } else { + charSequence9 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(9, charSequence9); + } else { + throw new RuntimeException(("Illegal union index for 'F9': "+ unionIndex9)); + } + } + int unionIndex10 = (decoder.readIndex()); + if (unionIndex10 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(10, null); + } else { + if (unionIndex10 == 1) { + Utf8 charSequence10; + Object oldString10 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(10); + if (oldString10 instanceof Utf8) { + charSequence10 = (decoder).readString(((Utf8) oldString10)); + } else { + charSequence10 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(10, charSequence10); + } else { + throw new RuntimeException(("Illegal union index for 'F10': "+ unionIndex10)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex11 = (decoder.readIndex()); + if (unionIndex11 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(11, null); + } else { + if (unionIndex11 == 1) { + Utf8 charSequence11; + Object oldString11 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(11); + if (oldString11 instanceof Utf8) { + charSequence11 = (decoder).readString(((Utf8) oldString11)); + } else { + charSequence11 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(11, charSequence11); + } else { + throw new RuntimeException(("Illegal union index for 'F11': "+ unionIndex11)); + } + } + int unionIndex12 = (decoder.readIndex()); + if (unionIndex12 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(12, null); + } else { + if (unionIndex12 == 1) { + Utf8 charSequence12; + Object oldString12 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(12); + if (oldString12 instanceof Utf8) { + charSequence12 = (decoder).readString(((Utf8) oldString12)); + } else { + charSequence12 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(12, charSequence12); + } else { + throw new RuntimeException(("Illegal union index for 'F12': "+ unionIndex12)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex13 = (decoder.readIndex()); + if (unionIndex13 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(13, null); + } else { + if (unionIndex13 == 1) { + Utf8 charSequence13; + Object oldString13 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(13); + if (oldString13 instanceof Utf8) { + charSequence13 = (decoder).readString(((Utf8) oldString13)); + } else { + charSequence13 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(13, charSequence13); + } else { + throw new RuntimeException(("Illegal union index for 'F13': "+ unionIndex13)); + } + } + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(14, null); + } else { + if (unionIndex14 == 1) { + Utf8 charSequence14; + Object oldString14 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(14); + if (oldString14 instanceof Utf8) { + charSequence14 = (decoder).readString(((Utf8) oldString14)); + } else { + charSequence14 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(14, charSequence14); + } else { + throw new RuntimeException(("Illegal union index for 'F14': "+ unionIndex14)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(15, null); + } else { + if (unionIndex15 == 1) { + Utf8 charSequence15; + Object oldString15 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(15); + if (oldString15 instanceof Utf8) { + charSequence15 = (decoder).readString(((Utf8) oldString15)); + } else { + charSequence15 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(15, charSequence15); + } else { + throw new RuntimeException(("Illegal union index for 'F15': "+ unionIndex15)); + } + } + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(16, null); + } else { + if (unionIndex16 == 1) { + Utf8 charSequence16; + Object oldString16 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(16); + if (oldString16 instanceof Utf8) { + charSequence16 = (decoder).readString(((Utf8) oldString16)); + } else { + charSequence16 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(16, charSequence16); + } else { + throw new RuntimeException(("Illegal union index for 'F16': "+ unionIndex16)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex17 = (decoder.readIndex()); + if (unionIndex17 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(17, null); + } else { + if (unionIndex17 == 1) { + Utf8 charSequence17; + Object oldString17 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(17); + if (oldString17 instanceof Utf8) { + charSequence17 = (decoder).readString(((Utf8) oldString17)); + } else { + charSequence17 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(17, charSequence17); + } else { + throw new RuntimeException(("Illegal union index for 'F17': "+ unionIndex17)); + } + } + int unionIndex18 = (decoder.readIndex()); + if (unionIndex18 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(18, null); + } else { + if (unionIndex18 == 1) { + Utf8 charSequence18; + Object oldString18 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(18); + if (oldString18 instanceof Utf8) { + charSequence18 = (decoder).readString(((Utf8) oldString18)); + } else { + charSequence18 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(18, charSequence18); + } else { + throw new RuntimeException(("Illegal union index for 'F18': "+ unionIndex18)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex19 = (decoder.readIndex()); + if (unionIndex19 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(19, null); + } else { + if (unionIndex19 == 1) { + Utf8 charSequence19; + Object oldString19 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(19); + if (oldString19 instanceof Utf8) { + charSequence19 = (decoder).readString(((Utf8) oldString19)); + } else { + charSequence19 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(19, charSequence19); + } else { + throw new RuntimeException(("Illegal union index for 'F19': "+ unionIndex19)); + } + } + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(20, null); + } else { + if (unionIndex20 == 1) { + Utf8 charSequence20; + Object oldString20 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(20); + if (oldString20 instanceof Utf8) { + charSequence20 = (decoder).readString(((Utf8) oldString20)); + } else { + charSequence20 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(20, charSequence20); + } else { + throw new RuntimeException(("Illegal union index for 'F20': "+ unionIndex20)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(21, null); + } else { + if (unionIndex21 == 1) { + Utf8 charSequence21; + Object oldString21 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(21); + if (oldString21 instanceof Utf8) { + charSequence21 = (decoder).readString(((Utf8) oldString21)); + } else { + charSequence21 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(21, charSequence21); + } else { + throw new RuntimeException(("Illegal union index for 'F21': "+ unionIndex21)); + } + } + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(22, null); + } else { + if (unionIndex22 == 1) { + Utf8 charSequence22; + Object oldString22 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(22); + if (oldString22 instanceof Utf8) { + charSequence22 = (decoder).readString(((Utf8) oldString22)); + } else { + charSequence22 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(22, charSequence22); + } else { + throw new RuntimeException(("Illegal union index for 'F22': "+ unionIndex22)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(23, null); + } else { + if (unionIndex23 == 1) { + Utf8 charSequence23; + Object oldString23 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(23); + if (oldString23 instanceof Utf8) { + charSequence23 = (decoder).readString(((Utf8) oldString23)); + } else { + charSequence23 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(23, charSequence23); + } else { + throw new RuntimeException(("Illegal union index for 'F23': "+ unionIndex23)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(24, null); + } else { + if (unionIndex24 == 1) { + Utf8 charSequence24; + Object oldString24 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(24); + if (oldString24 instanceof Utf8) { + charSequence24 = (decoder).readString(((Utf8) oldString24)); + } else { + charSequence24 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(24, charSequence24); + } else { + throw new RuntimeException(("Illegal union index for 'F24': "+ unionIndex24)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(25, null); + } else { + if (unionIndex25 == 1) { + Utf8 charSequence25; + Object oldString25 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(25); + if (oldString25 instanceof Utf8) { + charSequence25 = (decoder).readString(((Utf8) oldString25)); + } else { + charSequence25 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(25, charSequence25); + } else { + throw new RuntimeException(("Illegal union index for 'F25': "+ unionIndex25)); + } + } + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(26, null); + } else { + if (unionIndex26 == 1) { + Utf8 charSequence26; + Object oldString26 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(26); + if (oldString26 instanceof Utf8) { + charSequence26 = (decoder).readString(((Utf8) oldString26)); + } else { + charSequence26 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(26, charSequence26); + } else { + throw new RuntimeException(("Illegal union index for 'F26': "+ unionIndex26)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex27 = (decoder.readIndex()); + if (unionIndex27 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(27, null); + } else { + if (unionIndex27 == 1) { + Utf8 charSequence27; + Object oldString27 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(27); + if (oldString27 instanceof Utf8) { + charSequence27 = (decoder).readString(((Utf8) oldString27)); + } else { + charSequence27 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(27, charSequence27); + } else { + throw new RuntimeException(("Illegal union index for 'F27': "+ unionIndex27)); + } + } + int unionIndex28 = (decoder.readIndex()); + if (unionIndex28 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(28, null); + } else { + if (unionIndex28 == 1) { + Utf8 charSequence28; + Object oldString28 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(28); + if (oldString28 instanceof Utf8) { + charSequence28 = (decoder).readString(((Utf8) oldString28)); + } else { + charSequence28 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(28, charSequence28); + } else { + throw new RuntimeException(("Illegal union index for 'F28': "+ unionIndex28)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex29 = (decoder.readIndex()); + if (unionIndex29 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(29, null); + } else { + if (unionIndex29 == 1) { + Utf8 charSequence29; + Object oldString29 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(29); + if (oldString29 instanceof Utf8) { + charSequence29 = (decoder).readString(((Utf8) oldString29)); + } else { + charSequence29 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(29, charSequence29); + } else { + throw new RuntimeException(("Illegal union index for 'F29': "+ unionIndex29)); + } + } + int unionIndex30 = (decoder.readIndex()); + if (unionIndex30 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(30, null); + } else { + if (unionIndex30 == 1) { + Utf8 charSequence30; + Object oldString30 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(30); + if (oldString30 instanceof Utf8) { + charSequence30 = (decoder).readString(((Utf8) oldString30)); + } else { + charSequence30 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(30, charSequence30); + } else { + throw new RuntimeException(("Illegal union index for 'F30': "+ unionIndex30)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex31 = (decoder.readIndex()); + if (unionIndex31 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(31, null); + } else { + if (unionIndex31 == 1) { + Utf8 charSequence31; + Object oldString31 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(31); + if (oldString31 instanceof Utf8) { + charSequence31 = (decoder).readString(((Utf8) oldString31)); + } else { + charSequence31 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(31, charSequence31); + } else { + throw new RuntimeException(("Illegal union index for 'F31': "+ unionIndex31)); + } + } + int unionIndex32 = (decoder.readIndex()); + if (unionIndex32 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(32, null); + } else { + if (unionIndex32 == 1) { + Utf8 charSequence32; + Object oldString32 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(32); + if (oldString32 instanceof Utf8) { + charSequence32 = (decoder).readString(((Utf8) oldString32)); + } else { + charSequence32 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(32, charSequence32); + } else { + throw new RuntimeException(("Illegal union index for 'F32': "+ unionIndex32)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex33 = (decoder.readIndex()); + if (unionIndex33 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(33, null); + } else { + if (unionIndex33 == 1) { + Utf8 charSequence33; + Object oldString33 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(33); + if (oldString33 instanceof Utf8) { + charSequence33 = (decoder).readString(((Utf8) oldString33)); + } else { + charSequence33 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(33, charSequence33); + } else { + throw new RuntimeException(("Illegal union index for 'F33': "+ unionIndex33)); + } + } + int unionIndex34 = (decoder.readIndex()); + if (unionIndex34 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(34, null); + } else { + if (unionIndex34 == 1) { + Utf8 charSequence34; + Object oldString34 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(34); + if (oldString34 instanceof Utf8) { + charSequence34 = (decoder).readString(((Utf8) oldString34)); + } else { + charSequence34 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(34, charSequence34); + } else { + throw new RuntimeException(("Illegal union index for 'F34': "+ unionIndex34)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex35 = (decoder.readIndex()); + if (unionIndex35 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(35, null); + } else { + if (unionIndex35 == 1) { + Utf8 charSequence35; + Object oldString35 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(35); + if (oldString35 instanceof Utf8) { + charSequence35 = (decoder).readString(((Utf8) oldString35)); + } else { + charSequence35 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(35, charSequence35); + } else { + throw new RuntimeException(("Illegal union index for 'F35': "+ unionIndex35)); + } + } + int unionIndex36 = (decoder.readIndex()); + if (unionIndex36 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(36, null); + } else { + if (unionIndex36 == 1) { + Utf8 charSequence36; + Object oldString36 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(36); + if (oldString36 instanceof Utf8) { + charSequence36 = (decoder).readString(((Utf8) oldString36)); + } else { + charSequence36 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(36, charSequence36); + } else { + throw new RuntimeException(("Illegal union index for 'F36': "+ unionIndex36)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex37 = (decoder.readIndex()); + if (unionIndex37 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(37, null); + } else { + if (unionIndex37 == 1) { + Utf8 charSequence37; + Object oldString37 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(37); + if (oldString37 instanceof Utf8) { + charSequence37 = (decoder).readString(((Utf8) oldString37)); + } else { + charSequence37 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(37, charSequence37); + } else { + throw new RuntimeException(("Illegal union index for 'F37': "+ unionIndex37)); + } + } + int unionIndex38 = (decoder.readIndex()); + if (unionIndex38 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(38, null); + } else { + if (unionIndex38 == 1) { + Utf8 charSequence38; + Object oldString38 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(38); + if (oldString38 instanceof Utf8) { + charSequence38 = (decoder).readString(((Utf8) oldString38)); + } else { + charSequence38 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(38, charSequence38); + } else { + throw new RuntimeException(("Illegal union index for 'F38': "+ unionIndex38)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex39 = (decoder.readIndex()); + if (unionIndex39 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(39, null); + } else { + if (unionIndex39 == 1) { + Utf8 charSequence39; + Object oldString39 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(39); + if (oldString39 instanceof Utf8) { + charSequence39 = (decoder).readString(((Utf8) oldString39)); + } else { + charSequence39 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(39, charSequence39); + } else { + throw new RuntimeException(("Illegal union index for 'F39': "+ unionIndex39)); + } + } + int unionIndex40 = (decoder.readIndex()); + if (unionIndex40 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(40, null); + } else { + if (unionIndex40 == 1) { + Utf8 charSequence40; + Object oldString40 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(40); + if (oldString40 instanceof Utf8) { + charSequence40 = (decoder).readString(((Utf8) oldString40)); + } else { + charSequence40 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(40, charSequence40); + } else { + throw new RuntimeException(("Illegal union index for 'F40': "+ unionIndex40)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex41 = (decoder.readIndex()); + if (unionIndex41 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(41, null); + } else { + if (unionIndex41 == 1) { + Utf8 charSequence41; + Object oldString41 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(41); + if (oldString41 instanceof Utf8) { + charSequence41 = (decoder).readString(((Utf8) oldString41)); + } else { + charSequence41 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(41, charSequence41); + } else { + throw new RuntimeException(("Illegal union index for 'F41': "+ unionIndex41)); + } + } + int unionIndex42 = (decoder.readIndex()); + if (unionIndex42 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(42, null); + } else { + if (unionIndex42 == 1) { + Utf8 charSequence42; + Object oldString42 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(42); + if (oldString42 instanceof Utf8) { + charSequence42 = (decoder).readString(((Utf8) oldString42)); + } else { + charSequence42 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(42, charSequence42); + } else { + throw new RuntimeException(("Illegal union index for 'F42': "+ unionIndex42)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex43 = (decoder.readIndex()); + if (unionIndex43 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(43, null); + } else { + if (unionIndex43 == 1) { + Utf8 charSequence43; + Object oldString43 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(43); + if (oldString43 instanceof Utf8) { + charSequence43 = (decoder).readString(((Utf8) oldString43)); + } else { + charSequence43 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(43, charSequence43); + } else { + throw new RuntimeException(("Illegal union index for 'F43': "+ unionIndex43)); + } + } + int unionIndex44 = (decoder.readIndex()); + if (unionIndex44 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(44, null); + } else { + if (unionIndex44 == 1) { + Utf8 charSequence44; + Object oldString44 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(44); + if (oldString44 instanceof Utf8) { + charSequence44 = (decoder).readString(((Utf8) oldString44)); + } else { + charSequence44 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(44, charSequence44); + } else { + throw new RuntimeException(("Illegal union index for 'F44': "+ unionIndex44)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex45 = (decoder.readIndex()); + if (unionIndex45 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(45, null); + } else { + if (unionIndex45 == 1) { + Utf8 charSequence45; + Object oldString45 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(45); + if (oldString45 instanceof Utf8) { + charSequence45 = (decoder).readString(((Utf8) oldString45)); + } else { + charSequence45 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(45, charSequence45); + } else { + throw new RuntimeException(("Illegal union index for 'F45': "+ unionIndex45)); + } + } + int unionIndex46 = (decoder.readIndex()); + if (unionIndex46 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(46, null); + } else { + if (unionIndex46 == 1) { + Utf8 charSequence46; + Object oldString46 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(46); + if (oldString46 instanceof Utf8) { + charSequence46 = (decoder).readString(((Utf8) oldString46)); + } else { + charSequence46 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(46, charSequence46); + } else { + throw new RuntimeException(("Illegal union index for 'F46': "+ unionIndex46)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex47 = (decoder.readIndex()); + if (unionIndex47 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(47, null); + } else { + if (unionIndex47 == 1) { + Utf8 charSequence47; + Object oldString47 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(47); + if (oldString47 instanceof Utf8) { + charSequence47 = (decoder).readString(((Utf8) oldString47)); + } else { + charSequence47 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(47, charSequence47); + } else { + throw new RuntimeException(("Illegal union index for 'F47': "+ unionIndex47)); + } + } + int unionIndex48 = (decoder.readIndex()); + if (unionIndex48 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(48, null); + } else { + if (unionIndex48 == 1) { + Utf8 charSequence48; + Object oldString48 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(48); + if (oldString48 instanceof Utf8) { + charSequence48 = (decoder).readString(((Utf8) oldString48)); + } else { + charSequence48 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(48, charSequence48); + } else { + throw new RuntimeException(("Illegal union index for 'F48': "+ unionIndex48)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex49 = (decoder.readIndex()); + if (unionIndex49 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(49, null); + } else { + if (unionIndex49 == 1) { + Utf8 charSequence49; + Object oldString49 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(49); + if (oldString49 instanceof Utf8) { + charSequence49 = (decoder).readString(((Utf8) oldString49)); + } else { + charSequence49 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(49, charSequence49); + } else { + throw new RuntimeException(("Illegal union index for 'F49': "+ unionIndex49)); + } + } + int unionIndex50 = (decoder.readIndex()); + if (unionIndex50 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(50, null); + } else { + if (unionIndex50 == 1) { + Utf8 charSequence50; + Object oldString50 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(50); + if (oldString50 instanceof Utf8) { + charSequence50 = (decoder).readString(((Utf8) oldString50)); + } else { + charSequence50 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(50, charSequence50); + } else { + throw new RuntimeException(("Illegal union index for 'F50': "+ unionIndex50)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex51 = (decoder.readIndex()); + if (unionIndex51 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(51, null); + } else { + if (unionIndex51 == 1) { + Utf8 charSequence51; + Object oldString51 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(51); + if (oldString51 instanceof Utf8) { + charSequence51 = (decoder).readString(((Utf8) oldString51)); + } else { + charSequence51 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(51, charSequence51); + } else { + throw new RuntimeException(("Illegal union index for 'F51': "+ unionIndex51)); + } + } + int unionIndex52 = (decoder.readIndex()); + if (unionIndex52 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(52, null); + } else { + if (unionIndex52 == 1) { + Utf8 charSequence52; + Object oldString52 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(52); + if (oldString52 instanceof Utf8) { + charSequence52 = (decoder).readString(((Utf8) oldString52)); + } else { + charSequence52 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(52, charSequence52); + } else { + throw new RuntimeException(("Illegal union index for 'F52': "+ unionIndex52)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex53 = (decoder.readIndex()); + if (unionIndex53 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(53, null); + } else { + if (unionIndex53 == 1) { + Utf8 charSequence53; + Object oldString53 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(53); + if (oldString53 instanceof Utf8) { + charSequence53 = (decoder).readString(((Utf8) oldString53)); + } else { + charSequence53 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(53, charSequence53); + } else { + throw new RuntimeException(("Illegal union index for 'F53': "+ unionIndex53)); + } + } + int unionIndex54 = (decoder.readIndex()); + if (unionIndex54 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(54, null); + } else { + if (unionIndex54 == 1) { + Utf8 charSequence54; + Object oldString54 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(54); + if (oldString54 instanceof Utf8) { + charSequence54 = (decoder).readString(((Utf8) oldString54)); + } else { + charSequence54 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(54, charSequence54); + } else { + throw new RuntimeException(("Illegal union index for 'F54': "+ unionIndex54)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex55 = (decoder.readIndex()); + if (unionIndex55 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(55, null); + } else { + if (unionIndex55 == 1) { + Utf8 charSequence55; + Object oldString55 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(55); + if (oldString55 instanceof Utf8) { + charSequence55 = (decoder).readString(((Utf8) oldString55)); + } else { + charSequence55 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(55, charSequence55); + } else { + throw new RuntimeException(("Illegal union index for 'F55': "+ unionIndex55)); + } + } + int unionIndex56 = (decoder.readIndex()); + if (unionIndex56 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(56, null); + } else { + if (unionIndex56 == 1) { + Utf8 charSequence56; + Object oldString56 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(56); + if (oldString56 instanceof Utf8) { + charSequence56 = (decoder).readString(((Utf8) oldString56)); + } else { + charSequence56 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(56, charSequence56); + } else { + throw new RuntimeException(("Illegal union index for 'F56': "+ unionIndex56)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex57 = (decoder.readIndex()); + if (unionIndex57 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(57, null); + } else { + if (unionIndex57 == 1) { + Utf8 charSequence57; + Object oldString57 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(57); + if (oldString57 instanceof Utf8) { + charSequence57 = (decoder).readString(((Utf8) oldString57)); + } else { + charSequence57 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(57, charSequence57); + } else { + throw new RuntimeException(("Illegal union index for 'F57': "+ unionIndex57)); + } + } + int unionIndex58 = (decoder.readIndex()); + if (unionIndex58 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(58, null); + } else { + if (unionIndex58 == 1) { + Utf8 charSequence58; + Object oldString58 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(58); + if (oldString58 instanceof Utf8) { + charSequence58 = (decoder).readString(((Utf8) oldString58)); + } else { + charSequence58 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(58, charSequence58); + } else { + throw new RuntimeException(("Illegal union index for 'F58': "+ unionIndex58)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex59 = (decoder.readIndex()); + if (unionIndex59 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(59, null); + } else { + if (unionIndex59 == 1) { + Utf8 charSequence59; + Object oldString59 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(59); + if (oldString59 instanceof Utf8) { + charSequence59 = (decoder).readString(((Utf8) oldString59)); + } else { + charSequence59 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(59, charSequence59); + } else { + throw new RuntimeException(("Illegal union index for 'F59': "+ unionIndex59)); + } + } + int unionIndex60 = (decoder.readIndex()); + if (unionIndex60 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(60, null); + } else { + if (unionIndex60 == 1) { + Utf8 charSequence60; + Object oldString60 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(60); + if (oldString60 instanceof Utf8) { + charSequence60 = (decoder).readString(((Utf8) oldString60)); + } else { + charSequence60 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(60, charSequence60); + } else { + throw new RuntimeException(("Illegal union index for 'F60': "+ unionIndex60)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex61 = (decoder.readIndex()); + if (unionIndex61 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(61, null); + } else { + if (unionIndex61 == 1) { + Utf8 charSequence61; + Object oldString61 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(61); + if (oldString61 instanceof Utf8) { + charSequence61 = (decoder).readString(((Utf8) oldString61)); + } else { + charSequence61 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(61, charSequence61); + } else { + throw new RuntimeException(("Illegal union index for 'F61': "+ unionIndex61)); + } + } + int unionIndex62 = (decoder.readIndex()); + if (unionIndex62 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(62, null); + } else { + if (unionIndex62 == 1) { + Utf8 charSequence62; + Object oldString62 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(62); + if (oldString62 instanceof Utf8) { + charSequence62 = (decoder).readString(((Utf8) oldString62)); + } else { + charSequence62 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(62, charSequence62); + } else { + throw new RuntimeException(("Illegal union index for 'F62': "+ unionIndex62)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex63 = (decoder.readIndex()); + if (unionIndex63 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(63, null); + } else { + if (unionIndex63 == 1) { + Utf8 charSequence63; + Object oldString63 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(63); + if (oldString63 instanceof Utf8) { + charSequence63 = (decoder).readString(((Utf8) oldString63)); + } else { + charSequence63 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(63, charSequence63); + } else { + throw new RuntimeException(("Illegal union index for 'F63': "+ unionIndex63)); + } + } + int unionIndex64 = (decoder.readIndex()); + if (unionIndex64 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(64, null); + } else { + if (unionIndex64 == 1) { + Utf8 charSequence64; + Object oldString64 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(64); + if (oldString64 instanceof Utf8) { + charSequence64 = (decoder).readString(((Utf8) oldString64)); + } else { + charSequence64 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(64, charSequence64); + } else { + throw new RuntimeException(("Illegal union index for 'F64': "+ unionIndex64)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex65 = (decoder.readIndex()); + if (unionIndex65 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(65, null); + } else { + if (unionIndex65 == 1) { + Utf8 charSequence65; + Object oldString65 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(65); + if (oldString65 instanceof Utf8) { + charSequence65 = (decoder).readString(((Utf8) oldString65)); + } else { + charSequence65 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(65, charSequence65); + } else { + throw new RuntimeException(("Illegal union index for 'F65': "+ unionIndex65)); + } + } + int unionIndex66 = (decoder.readIndex()); + if (unionIndex66 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(66, null); + } else { + if (unionIndex66 == 1) { + Utf8 charSequence66; + Object oldString66 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(66); + if (oldString66 instanceof Utf8) { + charSequence66 = (decoder).readString(((Utf8) oldString66)); + } else { + charSequence66 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(66, charSequence66); + } else { + throw new RuntimeException(("Illegal union index for 'F66': "+ unionIndex66)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex67 = (decoder.readIndex()); + if (unionIndex67 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(67, null); + } else { + if (unionIndex67 == 1) { + Utf8 charSequence67; + Object oldString67 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(67); + if (oldString67 instanceof Utf8) { + charSequence67 = (decoder).readString(((Utf8) oldString67)); + } else { + charSequence67 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(67, charSequence67); + } else { + throw new RuntimeException(("Illegal union index for 'F67': "+ unionIndex67)); + } + } + int unionIndex68 = (decoder.readIndex()); + if (unionIndex68 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(68, null); + } else { + if (unionIndex68 == 1) { + Utf8 charSequence68; + Object oldString68 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(68); + if (oldString68 instanceof Utf8) { + charSequence68 = (decoder).readString(((Utf8) oldString68)); + } else { + charSequence68 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(68, charSequence68); + } else { + throw new RuntimeException(("Illegal union index for 'F68': "+ unionIndex68)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex69 = (decoder.readIndex()); + if (unionIndex69 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(69, null); + } else { + if (unionIndex69 == 1) { + Utf8 charSequence69; + Object oldString69 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(69); + if (oldString69 instanceof Utf8) { + charSequence69 = (decoder).readString(((Utf8) oldString69)); + } else { + charSequence69 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(69, charSequence69); + } else { + throw new RuntimeException(("Illegal union index for 'F69': "+ unionIndex69)); + } + } + int unionIndex70 = (decoder.readIndex()); + if (unionIndex70 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(70, null); + } else { + if (unionIndex70 == 1) { + Utf8 charSequence70; + Object oldString70 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(70); + if (oldString70 instanceof Utf8) { + charSequence70 = (decoder).readString(((Utf8) oldString70)); + } else { + charSequence70 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(70, charSequence70); + } else { + throw new RuntimeException(("Illegal union index for 'F70': "+ unionIndex70)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex71 = (decoder.readIndex()); + if (unionIndex71 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(71, null); + } else { + if (unionIndex71 == 1) { + Utf8 charSequence71; + Object oldString71 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(71); + if (oldString71 instanceof Utf8) { + charSequence71 = (decoder).readString(((Utf8) oldString71)); + } else { + charSequence71 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(71, charSequence71); + } else { + throw new RuntimeException(("Illegal union index for 'F71': "+ unionIndex71)); + } + } + int unionIndex72 = (decoder.readIndex()); + if (unionIndex72 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(72, null); + } else { + if (unionIndex72 == 1) { + Utf8 charSequence72; + Object oldString72 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(72); + if (oldString72 instanceof Utf8) { + charSequence72 = (decoder).readString(((Utf8) oldString72)); + } else { + charSequence72 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(72, charSequence72); + } else { + throw new RuntimeException(("Illegal union index for 'F72': "+ unionIndex72)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex73 = (decoder.readIndex()); + if (unionIndex73 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(73, null); + } else { + if (unionIndex73 == 1) { + Utf8 charSequence73; + Object oldString73 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(73); + if (oldString73 instanceof Utf8) { + charSequence73 = (decoder).readString(((Utf8) oldString73)); + } else { + charSequence73 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(73, charSequence73); + } else { + throw new RuntimeException(("Illegal union index for 'F73': "+ unionIndex73)); + } + } + int unionIndex74 = (decoder.readIndex()); + if (unionIndex74 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(74, null); + } else { + if (unionIndex74 == 1) { + Utf8 charSequence74; + Object oldString74 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(74); + if (oldString74 instanceof Utf8) { + charSequence74 = (decoder).readString(((Utf8) oldString74)); + } else { + charSequence74 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(74, charSequence74); + } else { + throw new RuntimeException(("Illegal union index for 'F74': "+ unionIndex74)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex75 = (decoder.readIndex()); + if (unionIndex75 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(75, null); + } else { + if (unionIndex75 == 1) { + Utf8 charSequence75; + Object oldString75 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(75); + if (oldString75 instanceof Utf8) { + charSequence75 = (decoder).readString(((Utf8) oldString75)); + } else { + charSequence75 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(75, charSequence75); + } else { + throw new RuntimeException(("Illegal union index for 'F75': "+ unionIndex75)); + } + } + int unionIndex76 = (decoder.readIndex()); + if (unionIndex76 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(76, null); + } else { + if (unionIndex76 == 1) { + Utf8 charSequence76; + Object oldString76 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(76); + if (oldString76 instanceof Utf8) { + charSequence76 = (decoder).readString(((Utf8) oldString76)); + } else { + charSequence76 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(76, charSequence76); + } else { + throw new RuntimeException(("Illegal union index for 'F76': "+ unionIndex76)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex77 = (decoder.readIndex()); + if (unionIndex77 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(77, null); + } else { + if (unionIndex77 == 1) { + Utf8 charSequence77; + Object oldString77 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(77); + if (oldString77 instanceof Utf8) { + charSequence77 = (decoder).readString(((Utf8) oldString77)); + } else { + charSequence77 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(77, charSequence77); + } else { + throw new RuntimeException(("Illegal union index for 'F77': "+ unionIndex77)); + } + } + int unionIndex78 = (decoder.readIndex()); + if (unionIndex78 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(78, null); + } else { + if (unionIndex78 == 1) { + Utf8 charSequence78; + Object oldString78 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(78); + if (oldString78 instanceof Utf8) { + charSequence78 = (decoder).readString(((Utf8) oldString78)); + } else { + charSequence78 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(78, charSequence78); + } else { + throw new RuntimeException(("Illegal union index for 'F78': "+ unionIndex78)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex79 = (decoder.readIndex()); + if (unionIndex79 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(79, null); + } else { + if (unionIndex79 == 1) { + Utf8 charSequence79; + Object oldString79 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(79); + if (oldString79 instanceof Utf8) { + charSequence79 = (decoder).readString(((Utf8) oldString79)); + } else { + charSequence79 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(79, charSequence79); + } else { + throw new RuntimeException(("Illegal union index for 'F79': "+ unionIndex79)); + } + } + int unionIndex80 = (decoder.readIndex()); + if (unionIndex80 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(80, null); + } else { + if (unionIndex80 == 1) { + Utf8 charSequence80; + Object oldString80 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(80); + if (oldString80 instanceof Utf8) { + charSequence80 = (decoder).readString(((Utf8) oldString80)); + } else { + charSequence80 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(80, charSequence80); + } else { + throw new RuntimeException(("Illegal union index for 'F80': "+ unionIndex80)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex81 = (decoder.readIndex()); + if (unionIndex81 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(81, null); + } else { + if (unionIndex81 == 1) { + Utf8 charSequence81; + Object oldString81 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(81); + if (oldString81 instanceof Utf8) { + charSequence81 = (decoder).readString(((Utf8) oldString81)); + } else { + charSequence81 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(81, charSequence81); + } else { + throw new RuntimeException(("Illegal union index for 'F81': "+ unionIndex81)); + } + } + int unionIndex82 = (decoder.readIndex()); + if (unionIndex82 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(82, null); + } else { + if (unionIndex82 == 1) { + Utf8 charSequence82; + Object oldString82 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(82); + if (oldString82 instanceof Utf8) { + charSequence82 = (decoder).readString(((Utf8) oldString82)); + } else { + charSequence82 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(82, charSequence82); + } else { + throw new RuntimeException(("Illegal union index for 'F82': "+ unionIndex82)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex83 = (decoder.readIndex()); + if (unionIndex83 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(83, null); + } else { + if (unionIndex83 == 1) { + Utf8 charSequence83; + Object oldString83 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(83); + if (oldString83 instanceof Utf8) { + charSequence83 = (decoder).readString(((Utf8) oldString83)); + } else { + charSequence83 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(83, charSequence83); + } else { + throw new RuntimeException(("Illegal union index for 'F83': "+ unionIndex83)); + } + } + int unionIndex84 = (decoder.readIndex()); + if (unionIndex84 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(84, null); + } else { + if (unionIndex84 == 1) { + Utf8 charSequence84; + Object oldString84 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(84); + if (oldString84 instanceof Utf8) { + charSequence84 = (decoder).readString(((Utf8) oldString84)); + } else { + charSequence84 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(84, charSequence84); + } else { + throw new RuntimeException(("Illegal union index for 'F84': "+ unionIndex84)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex85 = (decoder.readIndex()); + if (unionIndex85 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(85, null); + } else { + if (unionIndex85 == 1) { + Utf8 charSequence85; + Object oldString85 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(85); + if (oldString85 instanceof Utf8) { + charSequence85 = (decoder).readString(((Utf8) oldString85)); + } else { + charSequence85 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(85, charSequence85); + } else { + throw new RuntimeException(("Illegal union index for 'F85': "+ unionIndex85)); + } + } + int unionIndex86 = (decoder.readIndex()); + if (unionIndex86 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(86, null); + } else { + if (unionIndex86 == 1) { + Utf8 charSequence86; + Object oldString86 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(86); + if (oldString86 instanceof Utf8) { + charSequence86 = (decoder).readString(((Utf8) oldString86)); + } else { + charSequence86 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(86, charSequence86); + } else { + throw new RuntimeException(("Illegal union index for 'F86': "+ unionIndex86)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex87 = (decoder.readIndex()); + if (unionIndex87 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(87, null); + } else { + if (unionIndex87 == 1) { + Utf8 charSequence87; + Object oldString87 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(87); + if (oldString87 instanceof Utf8) { + charSequence87 = (decoder).readString(((Utf8) oldString87)); + } else { + charSequence87 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(87, charSequence87); + } else { + throw new RuntimeException(("Illegal union index for 'F87': "+ unionIndex87)); + } + } + int unionIndex88 = (decoder.readIndex()); + if (unionIndex88 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(88, null); + } else { + if (unionIndex88 == 1) { + Utf8 charSequence88; + Object oldString88 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(88); + if (oldString88 instanceof Utf8) { + charSequence88 = (decoder).readString(((Utf8) oldString88)); + } else { + charSequence88 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(88, charSequence88); + } else { + throw new RuntimeException(("Illegal union index for 'F88': "+ unionIndex88)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex89 = (decoder.readIndex()); + if (unionIndex89 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(89, null); + } else { + if (unionIndex89 == 1) { + Utf8 charSequence89; + Object oldString89 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(89); + if (oldString89 instanceof Utf8) { + charSequence89 = (decoder).readString(((Utf8) oldString89)); + } else { + charSequence89 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(89, charSequence89); + } else { + throw new RuntimeException(("Illegal union index for 'F89': "+ unionIndex89)); + } + } + int unionIndex90 = (decoder.readIndex()); + if (unionIndex90 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(90, null); + } else { + if (unionIndex90 == 1) { + Utf8 charSequence90; + Object oldString90 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(90); + if (oldString90 instanceof Utf8) { + charSequence90 = (decoder).readString(((Utf8) oldString90)); + } else { + charSequence90 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(90, charSequence90); + } else { + throw new RuntimeException(("Illegal union index for 'F90': "+ unionIndex90)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex91 = (decoder.readIndex()); + if (unionIndex91 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(91, null); + } else { + if (unionIndex91 == 1) { + Utf8 charSequence91; + Object oldString91 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(91); + if (oldString91 instanceof Utf8) { + charSequence91 = (decoder).readString(((Utf8) oldString91)); + } else { + charSequence91 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(91, charSequence91); + } else { + throw new RuntimeException(("Illegal union index for 'F91': "+ unionIndex91)); + } + } + int unionIndex92 = (decoder.readIndex()); + if (unionIndex92 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(92, null); + } else { + if (unionIndex92 == 1) { + Utf8 charSequence92; + Object oldString92 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(92); + if (oldString92 instanceof Utf8) { + charSequence92 = (decoder).readString(((Utf8) oldString92)); + } else { + charSequence92 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(92, charSequence92); + } else { + throw new RuntimeException(("Illegal union index for 'F92': "+ unionIndex92)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex93 = (decoder.readIndex()); + if (unionIndex93 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(93, null); + } else { + if (unionIndex93 == 1) { + Utf8 charSequence93; + Object oldString93 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(93); + if (oldString93 instanceof Utf8) { + charSequence93 = (decoder).readString(((Utf8) oldString93)); + } else { + charSequence93 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(93, charSequence93); + } else { + throw new RuntimeException(("Illegal union index for 'F93': "+ unionIndex93)); + } + } + int unionIndex94 = (decoder.readIndex()); + if (unionIndex94 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(94, null); + } else { + if (unionIndex94 == 1) { + Utf8 charSequence94; + Object oldString94 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(94); + if (oldString94 instanceof Utf8) { + charSequence94 = (decoder).readString(((Utf8) oldString94)); + } else { + charSequence94 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(94, charSequence94); + } else { + throw new RuntimeException(("Illegal union index for 'F94': "+ unionIndex94)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex95 = (decoder.readIndex()); + if (unionIndex95 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(95, null); + } else { + if (unionIndex95 == 1) { + Utf8 charSequence95; + Object oldString95 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(95); + if (oldString95 instanceof Utf8) { + charSequence95 = (decoder).readString(((Utf8) oldString95)); + } else { + charSequence95 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(95, charSequence95); + } else { + throw new RuntimeException(("Illegal union index for 'F95': "+ unionIndex95)); + } + } + int unionIndex96 = (decoder.readIndex()); + if (unionIndex96 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(96, null); + } else { + if (unionIndex96 == 1) { + Utf8 charSequence96; + Object oldString96 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(96); + if (oldString96 instanceof Utf8) { + charSequence96 = (decoder).readString(((Utf8) oldString96)); + } else { + charSequence96 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(96, charSequence96); + } else { + throw new RuntimeException(("Illegal union index for 'F96': "+ unionIndex96)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex97 = (decoder.readIndex()); + if (unionIndex97 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(97, null); + } else { + if (unionIndex97 == 1) { + Utf8 charSequence97; + Object oldString97 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(97); + if (oldString97 instanceof Utf8) { + charSequence97 = (decoder).readString(((Utf8) oldString97)); + } else { + charSequence97 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(97, charSequence97); + } else { + throw new RuntimeException(("Illegal union index for 'F97': "+ unionIndex97)); + } + } + int unionIndex98 = (decoder.readIndex()); + if (unionIndex98 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(98, null); + } else { + if (unionIndex98 == 1) { + Utf8 charSequence98; + Object oldString98 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(98); + if (oldString98 instanceof Utf8) { + charSequence98 = (decoder).readString(((Utf8) oldString98)); + } else { + charSequence98 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(98, charSequence98); + } else { + throw new RuntimeException(("Illegal union index for 'F98': "+ unionIndex98)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex99 = (decoder.readIndex()); + if (unionIndex99 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(99, null); + } else { + if (unionIndex99 == 1) { + Utf8 charSequence99; + Object oldString99 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(99); + if (oldString99 instanceof Utf8) { + charSequence99 = (decoder).readString(((Utf8) oldString99)); + } else { + charSequence99 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(99, charSequence99); + } else { + throw new RuntimeException(("Illegal union index for 'F99': "+ unionIndex99)); + } + } + int unionIndex100 = (decoder.readIndex()); + if (unionIndex100 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(100, null); + } else { + if (unionIndex100 == 1) { + Utf8 charSequence100; + Object oldString100 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(100); + if (oldString100 instanceof Utf8) { + charSequence100 = (decoder).readString(((Utf8) oldString100)); + } else { + charSequence100 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(100, charSequence100); + } else { + throw new RuntimeException(("Illegal union index for 'F100': "+ unionIndex100)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex101 = (decoder.readIndex()); + if (unionIndex101 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(101, null); + } else { + if (unionIndex101 == 1) { + Utf8 charSequence101; + Object oldString101 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(101); + if (oldString101 instanceof Utf8) { + charSequence101 = (decoder).readString(((Utf8) oldString101)); + } else { + charSequence101 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(101, charSequence101); + } else { + throw new RuntimeException(("Illegal union index for 'F101': "+ unionIndex101)); + } + } + int unionIndex102 = (decoder.readIndex()); + if (unionIndex102 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(102, null); + } else { + if (unionIndex102 == 1) { + Utf8 charSequence102; + Object oldString102 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(102); + if (oldString102 instanceof Utf8) { + charSequence102 = (decoder).readString(((Utf8) oldString102)); + } else { + charSequence102 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(102, charSequence102); + } else { + throw new RuntimeException(("Illegal union index for 'F102': "+ unionIndex102)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex103 = (decoder.readIndex()); + if (unionIndex103 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(103, null); + } else { + if (unionIndex103 == 1) { + Utf8 charSequence103; + Object oldString103 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(103); + if (oldString103 instanceof Utf8) { + charSequence103 = (decoder).readString(((Utf8) oldString103)); + } else { + charSequence103 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(103, charSequence103); + } else { + throw new RuntimeException(("Illegal union index for 'F103': "+ unionIndex103)); + } + } + int unionIndex104 = (decoder.readIndex()); + if (unionIndex104 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(104, null); + } else { + if (unionIndex104 == 1) { + Utf8 charSequence104; + Object oldString104 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(104); + if (oldString104 instanceof Utf8) { + charSequence104 = (decoder).readString(((Utf8) oldString104)); + } else { + charSequence104 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(104, charSequence104); + } else { + throw new RuntimeException(("Illegal union index for 'F104': "+ unionIndex104)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex105 = (decoder.readIndex()); + if (unionIndex105 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(105, null); + } else { + if (unionIndex105 == 1) { + Utf8 charSequence105; + Object oldString105 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(105); + if (oldString105 instanceof Utf8) { + charSequence105 = (decoder).readString(((Utf8) oldString105)); + } else { + charSequence105 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(105, charSequence105); + } else { + throw new RuntimeException(("Illegal union index for 'F105': "+ unionIndex105)); + } + } + int unionIndex106 = (decoder.readIndex()); + if (unionIndex106 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(106, null); + } else { + if (unionIndex106 == 1) { + Utf8 charSequence106; + Object oldString106 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(106); + if (oldString106 instanceof Utf8) { + charSequence106 = (decoder).readString(((Utf8) oldString106)); + } else { + charSequence106 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(106, charSequence106); + } else { + throw new RuntimeException(("Illegal union index for 'F106': "+ unionIndex106)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex107 = (decoder.readIndex()); + if (unionIndex107 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(107, null); + } else { + if (unionIndex107 == 1) { + Utf8 charSequence107; + Object oldString107 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(107); + if (oldString107 instanceof Utf8) { + charSequence107 = (decoder).readString(((Utf8) oldString107)); + } else { + charSequence107 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(107, charSequence107); + } else { + throw new RuntimeException(("Illegal union index for 'F107': "+ unionIndex107)); + } + } + int unionIndex108 = (decoder.readIndex()); + if (unionIndex108 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(108, null); + } else { + if (unionIndex108 == 1) { + Utf8 charSequence108; + Object oldString108 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(108); + if (oldString108 instanceof Utf8) { + charSequence108 = (decoder).readString(((Utf8) oldString108)); + } else { + charSequence108 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(108, charSequence108); + } else { + throw new RuntimeException(("Illegal union index for 'F108': "+ unionIndex108)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex109 = (decoder.readIndex()); + if (unionIndex109 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(109, null); + } else { + if (unionIndex109 == 1) { + Utf8 charSequence109; + Object oldString109 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(109); + if (oldString109 instanceof Utf8) { + charSequence109 = (decoder).readString(((Utf8) oldString109)); + } else { + charSequence109 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(109, charSequence109); + } else { + throw new RuntimeException(("Illegal union index for 'F109': "+ unionIndex109)); + } + } + int unionIndex110 = (decoder.readIndex()); + if (unionIndex110 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(110, null); + } else { + if (unionIndex110 == 1) { + Utf8 charSequence110; + Object oldString110 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(110); + if (oldString110 instanceof Utf8) { + charSequence110 = (decoder).readString(((Utf8) oldString110)); + } else { + charSequence110 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(110, charSequence110); + } else { + throw new RuntimeException(("Illegal union index for 'F110': "+ unionIndex110)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex111 = (decoder.readIndex()); + if (unionIndex111 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(111, null); + } else { + if (unionIndex111 == 1) { + Utf8 charSequence111; + Object oldString111 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(111); + if (oldString111 instanceof Utf8) { + charSequence111 = (decoder).readString(((Utf8) oldString111)); + } else { + charSequence111 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(111, charSequence111); + } else { + throw new RuntimeException(("Illegal union index for 'F111': "+ unionIndex111)); + } + } + int unionIndex112 = (decoder.readIndex()); + if (unionIndex112 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(112, null); + } else { + if (unionIndex112 == 1) { + Utf8 charSequence112; + Object oldString112 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(112); + if (oldString112 instanceof Utf8) { + charSequence112 = (decoder).readString(((Utf8) oldString112)); + } else { + charSequence112 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(112, charSequence112); + } else { + throw new RuntimeException(("Illegal union index for 'F112': "+ unionIndex112)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex113 = (decoder.readIndex()); + if (unionIndex113 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(113, null); + } else { + if (unionIndex113 == 1) { + Utf8 charSequence113; + Object oldString113 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(113); + if (oldString113 instanceof Utf8) { + charSequence113 = (decoder).readString(((Utf8) oldString113)); + } else { + charSequence113 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(113, charSequence113); + } else { + throw new RuntimeException(("Illegal union index for 'F113': "+ unionIndex113)); + } + } + int unionIndex114 = (decoder.readIndex()); + if (unionIndex114 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(114, null); + } else { + if (unionIndex114 == 1) { + Utf8 charSequence114; + Object oldString114 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(114); + if (oldString114 instanceof Utf8) { + charSequence114 = (decoder).readString(((Utf8) oldString114)); + } else { + charSequence114 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(114, charSequence114); + } else { + throw new RuntimeException(("Illegal union index for 'F114': "+ unionIndex114)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex115 = (decoder.readIndex()); + if (unionIndex115 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(115, null); + } else { + if (unionIndex115 == 1) { + Utf8 charSequence115; + Object oldString115 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(115); + if (oldString115 instanceof Utf8) { + charSequence115 = (decoder).readString(((Utf8) oldString115)); + } else { + charSequence115 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(115, charSequence115); + } else { + throw new RuntimeException(("Illegal union index for 'F115': "+ unionIndex115)); + } + } + int unionIndex116 = (decoder.readIndex()); + if (unionIndex116 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(116, null); + } else { + if (unionIndex116 == 1) { + Utf8 charSequence116; + Object oldString116 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(116); + if (oldString116 instanceof Utf8) { + charSequence116 = (decoder).readString(((Utf8) oldString116)); + } else { + charSequence116 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(116, charSequence116); + } else { + throw new RuntimeException(("Illegal union index for 'F116': "+ unionIndex116)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex117 = (decoder.readIndex()); + if (unionIndex117 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(117, null); + } else { + if (unionIndex117 == 1) { + Utf8 charSequence117; + Object oldString117 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(117); + if (oldString117 instanceof Utf8) { + charSequence117 = (decoder).readString(((Utf8) oldString117)); + } else { + charSequence117 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(117, charSequence117); + } else { + throw new RuntimeException(("Illegal union index for 'F117': "+ unionIndex117)); + } + } + int unionIndex118 = (decoder.readIndex()); + if (unionIndex118 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(118, null); + } else { + if (unionIndex118 == 1) { + Utf8 charSequence118; + Object oldString118 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(118); + if (oldString118 instanceof Utf8) { + charSequence118 = (decoder).readString(((Utf8) oldString118)); + } else { + charSequence118 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(118, charSequence118); + } else { + throw new RuntimeException(("Illegal union index for 'F118': "+ unionIndex118)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex119 = (decoder.readIndex()); + if (unionIndex119 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(119, null); + } else { + if (unionIndex119 == 1) { + Utf8 charSequence119; + Object oldString119 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(119); + if (oldString119 instanceof Utf8) { + charSequence119 = (decoder).readString(((Utf8) oldString119)); + } else { + charSequence119 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(119, charSequence119); + } else { + throw new RuntimeException(("Illegal union index for 'F119': "+ unionIndex119)); + } + } + int unionIndex120 = (decoder.readIndex()); + if (unionIndex120 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(120, null); + } else { + if (unionIndex120 == 1) { + Utf8 charSequence120; + Object oldString120 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(120); + if (oldString120 instanceof Utf8) { + charSequence120 = (decoder).readString(((Utf8) oldString120)); + } else { + charSequence120 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(120, charSequence120); + } else { + throw new RuntimeException(("Illegal union index for 'F120': "+ unionIndex120)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex121 = (decoder.readIndex()); + if (unionIndex121 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(121, null); + } else { + if (unionIndex121 == 1) { + Utf8 charSequence121; + Object oldString121 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(121); + if (oldString121 instanceof Utf8) { + charSequence121 = (decoder).readString(((Utf8) oldString121)); + } else { + charSequence121 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(121, charSequence121); + } else { + throw new RuntimeException(("Illegal union index for 'F121': "+ unionIndex121)); + } + } + int unionIndex122 = (decoder.readIndex()); + if (unionIndex122 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(122, null); + } else { + if (unionIndex122 == 1) { + Utf8 charSequence122; + Object oldString122 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(122); + if (oldString122 instanceof Utf8) { + charSequence122 = (decoder).readString(((Utf8) oldString122)); + } else { + charSequence122 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(122, charSequence122); + } else { + throw new RuntimeException(("Illegal union index for 'F122': "+ unionIndex122)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex123 = (decoder.readIndex()); + if (unionIndex123 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(123, null); + } else { + if (unionIndex123 == 1) { + Utf8 charSequence123; + Object oldString123 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(123); + if (oldString123 instanceof Utf8) { + charSequence123 = (decoder).readString(((Utf8) oldString123)); + } else { + charSequence123 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(123, charSequence123); + } else { + throw new RuntimeException(("Illegal union index for 'F123': "+ unionIndex123)); + } + } + int unionIndex124 = (decoder.readIndex()); + if (unionIndex124 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(124, null); + } else { + if (unionIndex124 == 1) { + Utf8 charSequence124; + Object oldString124 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(124); + if (oldString124 instanceof Utf8) { + charSequence124 = (decoder).readString(((Utf8) oldString124)); + } else { + charSequence124 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(124, charSequence124); + } else { + throw new RuntimeException(("Illegal union index for 'F124': "+ unionIndex124)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex125 = (decoder.readIndex()); + if (unionIndex125 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(125, null); + } else { + if (unionIndex125 == 1) { + Utf8 charSequence125; + Object oldString125 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(125); + if (oldString125 instanceof Utf8) { + charSequence125 = (decoder).readString(((Utf8) oldString125)); + } else { + charSequence125 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(125, charSequence125); + } else { + throw new RuntimeException(("Illegal union index for 'F125': "+ unionIndex125)); + } + } + int unionIndex126 = (decoder.readIndex()); + if (unionIndex126 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(126, null); + } else { + if (unionIndex126 == 1) { + Utf8 charSequence126; + Object oldString126 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(126); + if (oldString126 instanceof Utf8) { + charSequence126 = (decoder).readString(((Utf8) oldString126)); + } else { + charSequence126 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(126, charSequence126); + } else { + throw new RuntimeException(("Illegal union index for 'F126': "+ unionIndex126)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex127 = (decoder.readIndex()); + if (unionIndex127 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(127, null); + } else { + if (unionIndex127 == 1) { + Utf8 charSequence127; + Object oldString127 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(127); + if (oldString127 instanceof Utf8) { + charSequence127 = (decoder).readString(((Utf8) oldString127)); + } else { + charSequence127 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(127, charSequence127); + } else { + throw new RuntimeException(("Illegal union index for 'F127': "+ unionIndex127)); + } + } + int unionIndex128 = (decoder.readIndex()); + if (unionIndex128 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(128, null); + } else { + if (unionIndex128 == 1) { + Utf8 charSequence128; + Object oldString128 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(128); + if (oldString128 instanceof Utf8) { + charSequence128 = (decoder).readString(((Utf8) oldString128)); + } else { + charSequence128 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(128, charSequence128); + } else { + throw new RuntimeException(("Illegal union index for 'F128': "+ unionIndex128)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex129 = (decoder.readIndex()); + if (unionIndex129 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(129, null); + } else { + if (unionIndex129 == 1) { + Utf8 charSequence129; + Object oldString129 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(129); + if (oldString129 instanceof Utf8) { + charSequence129 = (decoder).readString(((Utf8) oldString129)); + } else { + charSequence129 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(129, charSequence129); + } else { + throw new RuntimeException(("Illegal union index for 'F129': "+ unionIndex129)); + } + } + int unionIndex130 = (decoder.readIndex()); + if (unionIndex130 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(130, null); + } else { + if (unionIndex130 == 1) { + Utf8 charSequence130; + Object oldString130 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(130); + if (oldString130 instanceof Utf8) { + charSequence130 = (decoder).readString(((Utf8) oldString130)); + } else { + charSequence130 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(130, charSequence130); + } else { + throw new RuntimeException(("Illegal union index for 'F130': "+ unionIndex130)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex131 = (decoder.readIndex()); + if (unionIndex131 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(131, null); + } else { + if (unionIndex131 == 1) { + Utf8 charSequence131; + Object oldString131 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(131); + if (oldString131 instanceof Utf8) { + charSequence131 = (decoder).readString(((Utf8) oldString131)); + } else { + charSequence131 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(131, charSequence131); + } else { + throw new RuntimeException(("Illegal union index for 'F131': "+ unionIndex131)); + } + } + int unionIndex132 = (decoder.readIndex()); + if (unionIndex132 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(132, null); + } else { + if (unionIndex132 == 1) { + Utf8 charSequence132; + Object oldString132 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(132); + if (oldString132 instanceof Utf8) { + charSequence132 = (decoder).readString(((Utf8) oldString132)); + } else { + charSequence132 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(132, charSequence132); + } else { + throw new RuntimeException(("Illegal union index for 'F132': "+ unionIndex132)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex133 = (decoder.readIndex()); + if (unionIndex133 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(133, null); + } else { + if (unionIndex133 == 1) { + Utf8 charSequence133; + Object oldString133 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(133); + if (oldString133 instanceof Utf8) { + charSequence133 = (decoder).readString(((Utf8) oldString133)); + } else { + charSequence133 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(133, charSequence133); + } else { + throw new RuntimeException(("Illegal union index for 'F133': "+ unionIndex133)); + } + } + int unionIndex134 = (decoder.readIndex()); + if (unionIndex134 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(134, null); + } else { + if (unionIndex134 == 1) { + Utf8 charSequence134; + Object oldString134 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(134); + if (oldString134 instanceof Utf8) { + charSequence134 = (decoder).readString(((Utf8) oldString134)); + } else { + charSequence134 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(134, charSequence134); + } else { + throw new RuntimeException(("Illegal union index for 'F134': "+ unionIndex134)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex135 = (decoder.readIndex()); + if (unionIndex135 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(135, null); + } else { + if (unionIndex135 == 1) { + Utf8 charSequence135; + Object oldString135 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(135); + if (oldString135 instanceof Utf8) { + charSequence135 = (decoder).readString(((Utf8) oldString135)); + } else { + charSequence135 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(135, charSequence135); + } else { + throw new RuntimeException(("Illegal union index for 'F135': "+ unionIndex135)); + } + } + int unionIndex136 = (decoder.readIndex()); + if (unionIndex136 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(136, null); + } else { + if (unionIndex136 == 1) { + Utf8 charSequence136; + Object oldString136 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(136); + if (oldString136 instanceof Utf8) { + charSequence136 = (decoder).readString(((Utf8) oldString136)); + } else { + charSequence136 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(136, charSequence136); + } else { + throw new RuntimeException(("Illegal union index for 'F136': "+ unionIndex136)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex137 = (decoder.readIndex()); + if (unionIndex137 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(137, null); + } else { + if (unionIndex137 == 1) { + Utf8 charSequence137; + Object oldString137 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(137); + if (oldString137 instanceof Utf8) { + charSequence137 = (decoder).readString(((Utf8) oldString137)); + } else { + charSequence137 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(137, charSequence137); + } else { + throw new RuntimeException(("Illegal union index for 'F137': "+ unionIndex137)); + } + } + int unionIndex138 = (decoder.readIndex()); + if (unionIndex138 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(138, null); + } else { + if (unionIndex138 == 1) { + Utf8 charSequence138; + Object oldString138 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(138); + if (oldString138 instanceof Utf8) { + charSequence138 = (decoder).readString(((Utf8) oldString138)); + } else { + charSequence138 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(138, charSequence138); + } else { + throw new RuntimeException(("Illegal union index for 'F138': "+ unionIndex138)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex139 = (decoder.readIndex()); + if (unionIndex139 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(139, null); + } else { + if (unionIndex139 == 1) { + Utf8 charSequence139; + Object oldString139 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(139); + if (oldString139 instanceof Utf8) { + charSequence139 = (decoder).readString(((Utf8) oldString139)); + } else { + charSequence139 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(139, charSequence139); + } else { + throw new RuntimeException(("Illegal union index for 'F139': "+ unionIndex139)); + } + } + int unionIndex140 = (decoder.readIndex()); + if (unionIndex140 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(140, null); + } else { + if (unionIndex140 == 1) { + Utf8 charSequence140; + Object oldString140 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(140); + if (oldString140 instanceof Utf8) { + charSequence140 = (decoder).readString(((Utf8) oldString140)); + } else { + charSequence140 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(140, charSequence140); + } else { + throw new RuntimeException(("Illegal union index for 'F140': "+ unionIndex140)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex141 = (decoder.readIndex()); + if (unionIndex141 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(141, null); + } else { + if (unionIndex141 == 1) { + Utf8 charSequence141; + Object oldString141 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(141); + if (oldString141 instanceof Utf8) { + charSequence141 = (decoder).readString(((Utf8) oldString141)); + } else { + charSequence141 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(141, charSequence141); + } else { + throw new RuntimeException(("Illegal union index for 'F141': "+ unionIndex141)); + } + } + int unionIndex142 = (decoder.readIndex()); + if (unionIndex142 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(142, null); + } else { + if (unionIndex142 == 1) { + Utf8 charSequence142; + Object oldString142 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(142); + if (oldString142 instanceof Utf8) { + charSequence142 = (decoder).readString(((Utf8) oldString142)); + } else { + charSequence142 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(142, charSequence142); + } else { + throw new RuntimeException(("Illegal union index for 'F142': "+ unionIndex142)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex143 = (decoder.readIndex()); + if (unionIndex143 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(143, null); + } else { + if (unionIndex143 == 1) { + Utf8 charSequence143; + Object oldString143 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(143); + if (oldString143 instanceof Utf8) { + charSequence143 = (decoder).readString(((Utf8) oldString143)); + } else { + charSequence143 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(143, charSequence143); + } else { + throw new RuntimeException(("Illegal union index for 'F143': "+ unionIndex143)); + } + } + int unionIndex144 = (decoder.readIndex()); + if (unionIndex144 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(144, null); + } else { + if (unionIndex144 == 1) { + Utf8 charSequence144; + Object oldString144 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(144); + if (oldString144 instanceof Utf8) { + charSequence144 = (decoder).readString(((Utf8) oldString144)); + } else { + charSequence144 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(144, charSequence144); + } else { + throw new RuntimeException(("Illegal union index for 'F144': "+ unionIndex144)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex145 = (decoder.readIndex()); + if (unionIndex145 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(145, null); + } else { + if (unionIndex145 == 1) { + Utf8 charSequence145; + Object oldString145 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(145); + if (oldString145 instanceof Utf8) { + charSequence145 = (decoder).readString(((Utf8) oldString145)); + } else { + charSequence145 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(145, charSequence145); + } else { + throw new RuntimeException(("Illegal union index for 'F145': "+ unionIndex145)); + } + } + int unionIndex146 = (decoder.readIndex()); + if (unionIndex146 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(146, null); + } else { + if (unionIndex146 == 1) { + Utf8 charSequence146; + Object oldString146 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(146); + if (oldString146 instanceof Utf8) { + charSequence146 = (decoder).readString(((Utf8) oldString146)); + } else { + charSequence146 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(146, charSequence146); + } else { + throw new RuntimeException(("Illegal union index for 'F146': "+ unionIndex146)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex147 = (decoder.readIndex()); + if (unionIndex147 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(147, null); + } else { + if (unionIndex147 == 1) { + Utf8 charSequence147; + Object oldString147 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(147); + if (oldString147 instanceof Utf8) { + charSequence147 = (decoder).readString(((Utf8) oldString147)); + } else { + charSequence147 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(147, charSequence147); + } else { + throw new RuntimeException(("Illegal union index for 'F147': "+ unionIndex147)); + } + } + int unionIndex148 = (decoder.readIndex()); + if (unionIndex148 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(148, null); + } else { + if (unionIndex148 == 1) { + Utf8 charSequence148; + Object oldString148 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(148); + if (oldString148 instanceof Utf8) { + charSequence148 = (decoder).readString(((Utf8) oldString148)); + } else { + charSequence148 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(148, charSequence148); + } else { + throw new RuntimeException(("Illegal union index for 'F148': "+ unionIndex148)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex149 = (decoder.readIndex()); + if (unionIndex149 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(149, null); + } else { + if (unionIndex149 == 1) { + Utf8 charSequence149; + Object oldString149 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(149); + if (oldString149 instanceof Utf8) { + charSequence149 = (decoder).readString(((Utf8) oldString149)); + } else { + charSequence149 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(149, charSequence149); + } else { + throw new RuntimeException(("Illegal union index for 'F149': "+ unionIndex149)); + } + } + int unionIndex150 = (decoder.readIndex()); + if (unionIndex150 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(150, null); + } else { + if (unionIndex150 == 1) { + Utf8 charSequence150; + Object oldString150 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(150); + if (oldString150 instanceof Utf8) { + charSequence150 = (decoder).readString(((Utf8) oldString150)); + } else { + charSequence150 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(150, charSequence150); + } else { + throw new RuntimeException(("Illegal union index for 'F150': "+ unionIndex150)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex151 = (decoder.readIndex()); + if (unionIndex151 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(151, null); + } else { + if (unionIndex151 == 1) { + Utf8 charSequence151; + Object oldString151 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(151); + if (oldString151 instanceof Utf8) { + charSequence151 = (decoder).readString(((Utf8) oldString151)); + } else { + charSequence151 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(151, charSequence151); + } else { + throw new RuntimeException(("Illegal union index for 'F151': "+ unionIndex151)); + } + } + int unionIndex152 = (decoder.readIndex()); + if (unionIndex152 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(152, null); + } else { + if (unionIndex152 == 1) { + Utf8 charSequence152; + Object oldString152 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(152); + if (oldString152 instanceof Utf8) { + charSequence152 = (decoder).readString(((Utf8) oldString152)); + } else { + charSequence152 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(152, charSequence152); + } else { + throw new RuntimeException(("Illegal union index for 'F152': "+ unionIndex152)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex153 = (decoder.readIndex()); + if (unionIndex153 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(153, null); + } else { + if (unionIndex153 == 1) { + Utf8 charSequence153; + Object oldString153 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(153); + if (oldString153 instanceof Utf8) { + charSequence153 = (decoder).readString(((Utf8) oldString153)); + } else { + charSequence153 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(153, charSequence153); + } else { + throw new RuntimeException(("Illegal union index for 'F153': "+ unionIndex153)); + } + } + int unionIndex154 = (decoder.readIndex()); + if (unionIndex154 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(154, null); + } else { + if (unionIndex154 == 1) { + Utf8 charSequence154; + Object oldString154 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(154); + if (oldString154 instanceof Utf8) { + charSequence154 = (decoder).readString(((Utf8) oldString154)); + } else { + charSequence154 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(154, charSequence154); + } else { + throw new RuntimeException(("Illegal union index for 'F154': "+ unionIndex154)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex155 = (decoder.readIndex()); + if (unionIndex155 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(155, null); + } else { + if (unionIndex155 == 1) { + Utf8 charSequence155; + Object oldString155 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(155); + if (oldString155 instanceof Utf8) { + charSequence155 = (decoder).readString(((Utf8) oldString155)); + } else { + charSequence155 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(155, charSequence155); + } else { + throw new RuntimeException(("Illegal union index for 'F155': "+ unionIndex155)); + } + } + int unionIndex156 = (decoder.readIndex()); + if (unionIndex156 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(156, null); + } else { + if (unionIndex156 == 1) { + Utf8 charSequence156; + Object oldString156 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(156); + if (oldString156 instanceof Utf8) { + charSequence156 = (decoder).readString(((Utf8) oldString156)); + } else { + charSequence156 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(156, charSequence156); + } else { + throw new RuntimeException(("Illegal union index for 'F156': "+ unionIndex156)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex157 = (decoder.readIndex()); + if (unionIndex157 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(157, null); + } else { + if (unionIndex157 == 1) { + Utf8 charSequence157; + Object oldString157 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(157); + if (oldString157 instanceof Utf8) { + charSequence157 = (decoder).readString(((Utf8) oldString157)); + } else { + charSequence157 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(157, charSequence157); + } else { + throw new RuntimeException(("Illegal union index for 'F157': "+ unionIndex157)); + } + } + int unionIndex158 = (decoder.readIndex()); + if (unionIndex158 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(158, null); + } else { + if (unionIndex158 == 1) { + Utf8 charSequence158; + Object oldString158 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(158); + if (oldString158 instanceof Utf8) { + charSequence158 = (decoder).readString(((Utf8) oldString158)); + } else { + charSequence158 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(158, charSequence158); + } else { + throw new RuntimeException(("Illegal union index for 'F158': "+ unionIndex158)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex159 = (decoder.readIndex()); + if (unionIndex159 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(159, null); + } else { + if (unionIndex159 == 1) { + Utf8 charSequence159; + Object oldString159 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(159); + if (oldString159 instanceof Utf8) { + charSequence159 = (decoder).readString(((Utf8) oldString159)); + } else { + charSequence159 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(159, charSequence159); + } else { + throw new RuntimeException(("Illegal union index for 'F159': "+ unionIndex159)); + } + } + int unionIndex160 = (decoder.readIndex()); + if (unionIndex160 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(160, null); + } else { + if (unionIndex160 == 1) { + Utf8 charSequence160; + Object oldString160 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(160); + if (oldString160 instanceof Utf8) { + charSequence160 = (decoder).readString(((Utf8) oldString160)); + } else { + charSequence160 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(160, charSequence160); + } else { + throw new RuntimeException(("Illegal union index for 'F160': "+ unionIndex160)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex161 = (decoder.readIndex()); + if (unionIndex161 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(161, null); + } else { + if (unionIndex161 == 1) { + Utf8 charSequence161; + Object oldString161 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(161); + if (oldString161 instanceof Utf8) { + charSequence161 = (decoder).readString(((Utf8) oldString161)); + } else { + charSequence161 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(161, charSequence161); + } else { + throw new RuntimeException(("Illegal union index for 'F161': "+ unionIndex161)); + } + } + int unionIndex162 = (decoder.readIndex()); + if (unionIndex162 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(162, null); + } else { + if (unionIndex162 == 1) { + Utf8 charSequence162; + Object oldString162 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(162); + if (oldString162 instanceof Utf8) { + charSequence162 = (decoder).readString(((Utf8) oldString162)); + } else { + charSequence162 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(162, charSequence162); + } else { + throw new RuntimeException(("Illegal union index for 'F162': "+ unionIndex162)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex163 = (decoder.readIndex()); + if (unionIndex163 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(163, null); + } else { + if (unionIndex163 == 1) { + Utf8 charSequence163; + Object oldString163 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(163); + if (oldString163 instanceof Utf8) { + charSequence163 = (decoder).readString(((Utf8) oldString163)); + } else { + charSequence163 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(163, charSequence163); + } else { + throw new RuntimeException(("Illegal union index for 'F163': "+ unionIndex163)); + } + } + int unionIndex164 = (decoder.readIndex()); + if (unionIndex164 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(164, null); + } else { + if (unionIndex164 == 1) { + Utf8 charSequence164; + Object oldString164 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(164); + if (oldString164 instanceof Utf8) { + charSequence164 = (decoder).readString(((Utf8) oldString164)); + } else { + charSequence164 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(164, charSequence164); + } else { + throw new RuntimeException(("Illegal union index for 'F164': "+ unionIndex164)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex165 = (decoder.readIndex()); + if (unionIndex165 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(165, null); + } else { + if (unionIndex165 == 1) { + Utf8 charSequence165; + Object oldString165 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(165); + if (oldString165 instanceof Utf8) { + charSequence165 = (decoder).readString(((Utf8) oldString165)); + } else { + charSequence165 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(165, charSequence165); + } else { + throw new RuntimeException(("Illegal union index for 'F165': "+ unionIndex165)); + } + } + int unionIndex166 = (decoder.readIndex()); + if (unionIndex166 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(166, null); + } else { + if (unionIndex166 == 1) { + Utf8 charSequence166; + Object oldString166 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(166); + if (oldString166 instanceof Utf8) { + charSequence166 = (decoder).readString(((Utf8) oldString166)); + } else { + charSequence166 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(166, charSequence166); + } else { + throw new RuntimeException(("Illegal union index for 'F166': "+ unionIndex166)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex167 = (decoder.readIndex()); + if (unionIndex167 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(167, null); + } else { + if (unionIndex167 == 1) { + Utf8 charSequence167; + Object oldString167 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(167); + if (oldString167 instanceof Utf8) { + charSequence167 = (decoder).readString(((Utf8) oldString167)); + } else { + charSequence167 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(167, charSequence167); + } else { + throw new RuntimeException(("Illegal union index for 'F167': "+ unionIndex167)); + } + } + int unionIndex168 = (decoder.readIndex()); + if (unionIndex168 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(168, null); + } else { + if (unionIndex168 == 1) { + Utf8 charSequence168; + Object oldString168 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(168); + if (oldString168 instanceof Utf8) { + charSequence168 = (decoder).readString(((Utf8) oldString168)); + } else { + charSequence168 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(168, charSequence168); + } else { + throw new RuntimeException(("Illegal union index for 'F168': "+ unionIndex168)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex169 = (decoder.readIndex()); + if (unionIndex169 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(169, null); + } else { + if (unionIndex169 == 1) { + Utf8 charSequence169; + Object oldString169 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(169); + if (oldString169 instanceof Utf8) { + charSequence169 = (decoder).readString(((Utf8) oldString169)); + } else { + charSequence169 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(169, charSequence169); + } else { + throw new RuntimeException(("Illegal union index for 'F169': "+ unionIndex169)); + } + } + int unionIndex170 = (decoder.readIndex()); + if (unionIndex170 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(170, null); + } else { + if (unionIndex170 == 1) { + Utf8 charSequence170; + Object oldString170 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(170); + if (oldString170 instanceof Utf8) { + charSequence170 = (decoder).readString(((Utf8) oldString170)); + } else { + charSequence170 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(170, charSequence170); + } else { + throw new RuntimeException(("Illegal union index for 'F170': "+ unionIndex170)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex171 = (decoder.readIndex()); + if (unionIndex171 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(171, null); + } else { + if (unionIndex171 == 1) { + Utf8 charSequence171; + Object oldString171 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(171); + if (oldString171 instanceof Utf8) { + charSequence171 = (decoder).readString(((Utf8) oldString171)); + } else { + charSequence171 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(171, charSequence171); + } else { + throw new RuntimeException(("Illegal union index for 'F171': "+ unionIndex171)); + } + } + int unionIndex172 = (decoder.readIndex()); + if (unionIndex172 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(172, null); + } else { + if (unionIndex172 == 1) { + Utf8 charSequence172; + Object oldString172 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(172); + if (oldString172 instanceof Utf8) { + charSequence172 = (decoder).readString(((Utf8) oldString172)); + } else { + charSequence172 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(172, charSequence172); + } else { + throw new RuntimeException(("Illegal union index for 'F172': "+ unionIndex172)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex173 = (decoder.readIndex()); + if (unionIndex173 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(173, null); + } else { + if (unionIndex173 == 1) { + Utf8 charSequence173; + Object oldString173 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(173); + if (oldString173 instanceof Utf8) { + charSequence173 = (decoder).readString(((Utf8) oldString173)); + } else { + charSequence173 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(173, charSequence173); + } else { + throw new RuntimeException(("Illegal union index for 'F173': "+ unionIndex173)); + } + } + int unionIndex174 = (decoder.readIndex()); + if (unionIndex174 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(174, null); + } else { + if (unionIndex174 == 1) { + Utf8 charSequence174; + Object oldString174 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(174); + if (oldString174 instanceof Utf8) { + charSequence174 = (decoder).readString(((Utf8) oldString174)); + } else { + charSequence174 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(174, charSequence174); + } else { + throw new RuntimeException(("Illegal union index for 'F174': "+ unionIndex174)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex175 = (decoder.readIndex()); + if (unionIndex175 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(175, null); + } else { + if (unionIndex175 == 1) { + Utf8 charSequence175; + Object oldString175 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(175); + if (oldString175 instanceof Utf8) { + charSequence175 = (decoder).readString(((Utf8) oldString175)); + } else { + charSequence175 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(175, charSequence175); + } else { + throw new RuntimeException(("Illegal union index for 'F175': "+ unionIndex175)); + } + } + int unionIndex176 = (decoder.readIndex()); + if (unionIndex176 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(176, null); + } else { + if (unionIndex176 == 1) { + Utf8 charSequence176; + Object oldString176 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(176); + if (oldString176 instanceof Utf8) { + charSequence176 = (decoder).readString(((Utf8) oldString176)); + } else { + charSequence176 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(176, charSequence176); + } else { + throw new RuntimeException(("Illegal union index for 'F176': "+ unionIndex176)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex177 = (decoder.readIndex()); + if (unionIndex177 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(177, null); + } else { + if (unionIndex177 == 1) { + Utf8 charSequence177; + Object oldString177 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(177); + if (oldString177 instanceof Utf8) { + charSequence177 = (decoder).readString(((Utf8) oldString177)); + } else { + charSequence177 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(177, charSequence177); + } else { + throw new RuntimeException(("Illegal union index for 'F177': "+ unionIndex177)); + } + } + int unionIndex178 = (decoder.readIndex()); + if (unionIndex178 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(178, null); + } else { + if (unionIndex178 == 1) { + Utf8 charSequence178; + Object oldString178 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(178); + if (oldString178 instanceof Utf8) { + charSequence178 = (decoder).readString(((Utf8) oldString178)); + } else { + charSequence178 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(178, charSequence178); + } else { + throw new RuntimeException(("Illegal union index for 'F178': "+ unionIndex178)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex179 = (decoder.readIndex()); + if (unionIndex179 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(179, null); + } else { + if (unionIndex179 == 1) { + Utf8 charSequence179; + Object oldString179 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(179); + if (oldString179 instanceof Utf8) { + charSequence179 = (decoder).readString(((Utf8) oldString179)); + } else { + charSequence179 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(179, charSequence179); + } else { + throw new RuntimeException(("Illegal union index for 'F179': "+ unionIndex179)); + } + } + int unionIndex180 = (decoder.readIndex()); + if (unionIndex180 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(180, null); + } else { + if (unionIndex180 == 1) { + Utf8 charSequence180; + Object oldString180 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(180); + if (oldString180 instanceof Utf8) { + charSequence180 = (decoder).readString(((Utf8) oldString180)); + } else { + charSequence180 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(180, charSequence180); + } else { + throw new RuntimeException(("Illegal union index for 'F180': "+ unionIndex180)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex181 = (decoder.readIndex()); + if (unionIndex181 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(181, null); + } else { + if (unionIndex181 == 1) { + Utf8 charSequence181; + Object oldString181 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(181); + if (oldString181 instanceof Utf8) { + charSequence181 = (decoder).readString(((Utf8) oldString181)); + } else { + charSequence181 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(181, charSequence181); + } else { + throw new RuntimeException(("Illegal union index for 'F181': "+ unionIndex181)); + } + } + int unionIndex182 = (decoder.readIndex()); + if (unionIndex182 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(182, null); + } else { + if (unionIndex182 == 1) { + Utf8 charSequence182; + Object oldString182 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(182); + if (oldString182 instanceof Utf8) { + charSequence182 = (decoder).readString(((Utf8) oldString182)); + } else { + charSequence182 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(182, charSequence182); + } else { + throw new RuntimeException(("Illegal union index for 'F182': "+ unionIndex182)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex183 = (decoder.readIndex()); + if (unionIndex183 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(183, null); + } else { + if (unionIndex183 == 1) { + Utf8 charSequence183; + Object oldString183 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(183); + if (oldString183 instanceof Utf8) { + charSequence183 = (decoder).readString(((Utf8) oldString183)); + } else { + charSequence183 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(183, charSequence183); + } else { + throw new RuntimeException(("Illegal union index for 'F183': "+ unionIndex183)); + } + } + int unionIndex184 = (decoder.readIndex()); + if (unionIndex184 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(184, null); + } else { + if (unionIndex184 == 1) { + Utf8 charSequence184; + Object oldString184 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(184); + if (oldString184 instanceof Utf8) { + charSequence184 = (decoder).readString(((Utf8) oldString184)); + } else { + charSequence184 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(184, charSequence184); + } else { + throw new RuntimeException(("Illegal union index for 'F184': "+ unionIndex184)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex185 = (decoder.readIndex()); + if (unionIndex185 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(185, null); + } else { + if (unionIndex185 == 1) { + Utf8 charSequence185; + Object oldString185 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(185); + if (oldString185 instanceof Utf8) { + charSequence185 = (decoder).readString(((Utf8) oldString185)); + } else { + charSequence185 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(185, charSequence185); + } else { + throw new RuntimeException(("Illegal union index for 'F185': "+ unionIndex185)); + } + } + int unionIndex186 = (decoder.readIndex()); + if (unionIndex186 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(186, null); + } else { + if (unionIndex186 == 1) { + Utf8 charSequence186; + Object oldString186 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(186); + if (oldString186 instanceof Utf8) { + charSequence186 = (decoder).readString(((Utf8) oldString186)); + } else { + charSequence186 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(186, charSequence186); + } else { + throw new RuntimeException(("Illegal union index for 'F186': "+ unionIndex186)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex187 = (decoder.readIndex()); + if (unionIndex187 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(187, null); + } else { + if (unionIndex187 == 1) { + Utf8 charSequence187; + Object oldString187 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(187); + if (oldString187 instanceof Utf8) { + charSequence187 = (decoder).readString(((Utf8) oldString187)); + } else { + charSequence187 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(187, charSequence187); + } else { + throw new RuntimeException(("Illegal union index for 'F187': "+ unionIndex187)); + } + } + int unionIndex188 = (decoder.readIndex()); + if (unionIndex188 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(188, null); + } else { + if (unionIndex188 == 1) { + Utf8 charSequence188; + Object oldString188 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(188); + if (oldString188 instanceof Utf8) { + charSequence188 = (decoder).readString(((Utf8) oldString188)); + } else { + charSequence188 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(188, charSequence188); + } else { + throw new RuntimeException(("Illegal union index for 'F188': "+ unionIndex188)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex189 = (decoder.readIndex()); + if (unionIndex189 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(189, null); + } else { + if (unionIndex189 == 1) { + Utf8 charSequence189; + Object oldString189 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(189); + if (oldString189 instanceof Utf8) { + charSequence189 = (decoder).readString(((Utf8) oldString189)); + } else { + charSequence189 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(189, charSequence189); + } else { + throw new RuntimeException(("Illegal union index for 'F189': "+ unionIndex189)); + } + } + int unionIndex190 = (decoder.readIndex()); + if (unionIndex190 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(190, null); + } else { + if (unionIndex190 == 1) { + Utf8 charSequence190; + Object oldString190 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(190); + if (oldString190 instanceof Utf8) { + charSequence190 = (decoder).readString(((Utf8) oldString190)); + } else { + charSequence190 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(190, charSequence190); + } else { + throw new RuntimeException(("Illegal union index for 'F190': "+ unionIndex190)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex191 = (decoder.readIndex()); + if (unionIndex191 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(191, null); + } else { + if (unionIndex191 == 1) { + Utf8 charSequence191; + Object oldString191 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(191); + if (oldString191 instanceof Utf8) { + charSequence191 = (decoder).readString(((Utf8) oldString191)); + } else { + charSequence191 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(191, charSequence191); + } else { + throw new RuntimeException(("Illegal union index for 'F191': "+ unionIndex191)); + } + } + int unionIndex192 = (decoder.readIndex()); + if (unionIndex192 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(192, null); + } else { + if (unionIndex192 == 1) { + Utf8 charSequence192; + Object oldString192 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(192); + if (oldString192 instanceof Utf8) { + charSequence192 = (decoder).readString(((Utf8) oldString192)); + } else { + charSequence192 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(192, charSequence192); + } else { + throw new RuntimeException(("Illegal union index for 'F192': "+ unionIndex192)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex193 = (decoder.readIndex()); + if (unionIndex193 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(193, null); + } else { + if (unionIndex193 == 1) { + Utf8 charSequence193; + Object oldString193 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(193); + if (oldString193 instanceof Utf8) { + charSequence193 = (decoder).readString(((Utf8) oldString193)); + } else { + charSequence193 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(193, charSequence193); + } else { + throw new RuntimeException(("Illegal union index for 'F193': "+ unionIndex193)); + } + } + int unionIndex194 = (decoder.readIndex()); + if (unionIndex194 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(194, null); + } else { + if (unionIndex194 == 1) { + Utf8 charSequence194; + Object oldString194 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(194); + if (oldString194 instanceof Utf8) { + charSequence194 = (decoder).readString(((Utf8) oldString194)); + } else { + charSequence194 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(194, charSequence194); + } else { + throw new RuntimeException(("Illegal union index for 'F194': "+ unionIndex194)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex195 = (decoder.readIndex()); + if (unionIndex195 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(195, null); + } else { + if (unionIndex195 == 1) { + Utf8 charSequence195; + Object oldString195 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(195); + if (oldString195 instanceof Utf8) { + charSequence195 = (decoder).readString(((Utf8) oldString195)); + } else { + charSequence195 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(195, charSequence195); + } else { + throw new RuntimeException(("Illegal union index for 'F195': "+ unionIndex195)); + } + } + int unionIndex196 = (decoder.readIndex()); + if (unionIndex196 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(196, null); + } else { + if (unionIndex196 == 1) { + Utf8 charSequence196; + Object oldString196 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(196); + if (oldString196 instanceof Utf8) { + charSequence196 = (decoder).readString(((Utf8) oldString196)); + } else { + charSequence196 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(196, charSequence196); + } else { + throw new RuntimeException(("Illegal union index for 'F196': "+ unionIndex196)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex197 = (decoder.readIndex()); + if (unionIndex197 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(197, null); + } else { + if (unionIndex197 == 1) { + Utf8 charSequence197; + Object oldString197 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(197); + if (oldString197 instanceof Utf8) { + charSequence197 = (decoder).readString(((Utf8) oldString197)); + } else { + charSequence197 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(197, charSequence197); + } else { + throw new RuntimeException(("Illegal union index for 'F197': "+ unionIndex197)); + } + } + int unionIndex198 = (decoder.readIndex()); + if (unionIndex198 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(198, null); + } else { + if (unionIndex198 == 1) { + Utf8 charSequence198; + Object oldString198 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(198); + if (oldString198 instanceof Utf8) { + charSequence198 = (decoder).readString(((Utf8) oldString198)); + } else { + charSequence198 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(198, charSequence198); + } else { + throw new RuntimeException(("Illegal union index for 'F198': "+ unionIndex198)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex199 = (decoder.readIndex()); + if (unionIndex199 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(199, null); + } else { + if (unionIndex199 == 1) { + Utf8 charSequence199; + Object oldString199 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(199); + if (oldString199 instanceof Utf8) { + charSequence199 = (decoder).readString(((Utf8) oldString199)); + } else { + charSequence199 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(199, charSequence199); + } else { + throw new RuntimeException(("Illegal union index for 'F199': "+ unionIndex199)); + } + } + int unionIndex200 = (decoder.readIndex()); + if (unionIndex200 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(200, null); + } else { + if (unionIndex200 == 1) { + Utf8 charSequence200; + Object oldString200 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(200); + if (oldString200 instanceof Utf8) { + charSequence200 = (decoder).readString(((Utf8) oldString200)); + } else { + charSequence200 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(200, charSequence200); + } else { + throw new RuntimeException(("Illegal union index for 'F200': "+ unionIndex200)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex201 = (decoder.readIndex()); + if (unionIndex201 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(201, null); + } else { + if (unionIndex201 == 1) { + Utf8 charSequence201; + Object oldString201 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(201); + if (oldString201 instanceof Utf8) { + charSequence201 = (decoder).readString(((Utf8) oldString201)); + } else { + charSequence201 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(201, charSequence201); + } else { + throw new RuntimeException(("Illegal union index for 'F201': "+ unionIndex201)); + } + } + int unionIndex202 = (decoder.readIndex()); + if (unionIndex202 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(202, null); + } else { + if (unionIndex202 == 1) { + Utf8 charSequence202; + Object oldString202 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(202); + if (oldString202 instanceof Utf8) { + charSequence202 = (decoder).readString(((Utf8) oldString202)); + } else { + charSequence202 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(202, charSequence202); + } else { + throw new RuntimeException(("Illegal union index for 'F202': "+ unionIndex202)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex203 = (decoder.readIndex()); + if (unionIndex203 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(203, null); + } else { + if (unionIndex203 == 1) { + Utf8 charSequence203; + Object oldString203 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(203); + if (oldString203 instanceof Utf8) { + charSequence203 = (decoder).readString(((Utf8) oldString203)); + } else { + charSequence203 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(203, charSequence203); + } else { + throw new RuntimeException(("Illegal union index for 'F203': "+ unionIndex203)); + } + } + int unionIndex204 = (decoder.readIndex()); + if (unionIndex204 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(204, null); + } else { + if (unionIndex204 == 1) { + Utf8 charSequence204; + Object oldString204 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(204); + if (oldString204 instanceof Utf8) { + charSequence204 = (decoder).readString(((Utf8) oldString204)); + } else { + charSequence204 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(204, charSequence204); + } else { + throw new RuntimeException(("Illegal union index for 'F204': "+ unionIndex204)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex205 = (decoder.readIndex()); + if (unionIndex205 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(205, null); + } else { + if (unionIndex205 == 1) { + Utf8 charSequence205; + Object oldString205 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(205); + if (oldString205 instanceof Utf8) { + charSequence205 = (decoder).readString(((Utf8) oldString205)); + } else { + charSequence205 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(205, charSequence205); + } else { + throw new RuntimeException(("Illegal union index for 'F205': "+ unionIndex205)); + } + } + int unionIndex206 = (decoder.readIndex()); + if (unionIndex206 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(206, null); + } else { + if (unionIndex206 == 1) { + Utf8 charSequence206; + Object oldString206 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(206); + if (oldString206 instanceof Utf8) { + charSequence206 = (decoder).readString(((Utf8) oldString206)); + } else { + charSequence206 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(206, charSequence206); + } else { + throw new RuntimeException(("Illegal union index for 'F206': "+ unionIndex206)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex207 = (decoder.readIndex()); + if (unionIndex207 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(207, null); + } else { + if (unionIndex207 == 1) { + Utf8 charSequence207; + Object oldString207 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(207); + if (oldString207 instanceof Utf8) { + charSequence207 = (decoder).readString(((Utf8) oldString207)); + } else { + charSequence207 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(207, charSequence207); + } else { + throw new RuntimeException(("Illegal union index for 'F207': "+ unionIndex207)); + } + } + int unionIndex208 = (decoder.readIndex()); + if (unionIndex208 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(208, null); + } else { + if (unionIndex208 == 1) { + Utf8 charSequence208; + Object oldString208 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(208); + if (oldString208 instanceof Utf8) { + charSequence208 = (decoder).readString(((Utf8) oldString208)); + } else { + charSequence208 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(208, charSequence208); + } else { + throw new RuntimeException(("Illegal union index for 'F208': "+ unionIndex208)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex209 = (decoder.readIndex()); + if (unionIndex209 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(209, null); + } else { + if (unionIndex209 == 1) { + Utf8 charSequence209; + Object oldString209 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(209); + if (oldString209 instanceof Utf8) { + charSequence209 = (decoder).readString(((Utf8) oldString209)); + } else { + charSequence209 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(209, charSequence209); + } else { + throw new RuntimeException(("Illegal union index for 'F209': "+ unionIndex209)); + } + } + int unionIndex210 = (decoder.readIndex()); + if (unionIndex210 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(210, null); + } else { + if (unionIndex210 == 1) { + Utf8 charSequence210; + Object oldString210 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(210); + if (oldString210 instanceof Utf8) { + charSequence210 = (decoder).readString(((Utf8) oldString210)); + } else { + charSequence210 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(210, charSequence210); + } else { + throw new RuntimeException(("Illegal union index for 'F210': "+ unionIndex210)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex211 = (decoder.readIndex()); + if (unionIndex211 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(211, null); + } else { + if (unionIndex211 == 1) { + Utf8 charSequence211; + Object oldString211 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(211); + if (oldString211 instanceof Utf8) { + charSequence211 = (decoder).readString(((Utf8) oldString211)); + } else { + charSequence211 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(211, charSequence211); + } else { + throw new RuntimeException(("Illegal union index for 'F211': "+ unionIndex211)); + } + } + int unionIndex212 = (decoder.readIndex()); + if (unionIndex212 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(212, null); + } else { + if (unionIndex212 == 1) { + Utf8 charSequence212; + Object oldString212 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(212); + if (oldString212 instanceof Utf8) { + charSequence212 = (decoder).readString(((Utf8) oldString212)); + } else { + charSequence212 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(212, charSequence212); + } else { + throw new RuntimeException(("Illegal union index for 'F212': "+ unionIndex212)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex213 = (decoder.readIndex()); + if (unionIndex213 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(213, null); + } else { + if (unionIndex213 == 1) { + Utf8 charSequence213; + Object oldString213 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(213); + if (oldString213 instanceof Utf8) { + charSequence213 = (decoder).readString(((Utf8) oldString213)); + } else { + charSequence213 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(213, charSequence213); + } else { + throw new RuntimeException(("Illegal union index for 'F213': "+ unionIndex213)); + } + } + int unionIndex214 = (decoder.readIndex()); + if (unionIndex214 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(214, null); + } else { + if (unionIndex214 == 1) { + Utf8 charSequence214; + Object oldString214 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(214); + if (oldString214 instanceof Utf8) { + charSequence214 = (decoder).readString(((Utf8) oldString214)); + } else { + charSequence214 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(214, charSequence214); + } else { + throw new RuntimeException(("Illegal union index for 'F214': "+ unionIndex214)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex215 = (decoder.readIndex()); + if (unionIndex215 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(215, null); + } else { + if (unionIndex215 == 1) { + Utf8 charSequence215; + Object oldString215 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(215); + if (oldString215 instanceof Utf8) { + charSequence215 = (decoder).readString(((Utf8) oldString215)); + } else { + charSequence215 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(215, charSequence215); + } else { + throw new RuntimeException(("Illegal union index for 'F215': "+ unionIndex215)); + } + } + int unionIndex216 = (decoder.readIndex()); + if (unionIndex216 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(216, null); + } else { + if (unionIndex216 == 1) { + Utf8 charSequence216; + Object oldString216 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(216); + if (oldString216 instanceof Utf8) { + charSequence216 = (decoder).readString(((Utf8) oldString216)); + } else { + charSequence216 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(216, charSequence216); + } else { + throw new RuntimeException(("Illegal union index for 'F216': "+ unionIndex216)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex217 = (decoder.readIndex()); + if (unionIndex217 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(217, null); + } else { + if (unionIndex217 == 1) { + Utf8 charSequence217; + Object oldString217 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(217); + if (oldString217 instanceof Utf8) { + charSequence217 = (decoder).readString(((Utf8) oldString217)); + } else { + charSequence217 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(217, charSequence217); + } else { + throw new RuntimeException(("Illegal union index for 'F217': "+ unionIndex217)); + } + } + int unionIndex218 = (decoder.readIndex()); + if (unionIndex218 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(218, null); + } else { + if (unionIndex218 == 1) { + Utf8 charSequence218; + Object oldString218 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(218); + if (oldString218 instanceof Utf8) { + charSequence218 = (decoder).readString(((Utf8) oldString218)); + } else { + charSequence218 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(218, charSequence218); + } else { + throw new RuntimeException(("Illegal union index for 'F218': "+ unionIndex218)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex219 = (decoder.readIndex()); + if (unionIndex219 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(219, null); + } else { + if (unionIndex219 == 1) { + Utf8 charSequence219; + Object oldString219 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(219); + if (oldString219 instanceof Utf8) { + charSequence219 = (decoder).readString(((Utf8) oldString219)); + } else { + charSequence219 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(219, charSequence219); + } else { + throw new RuntimeException(("Illegal union index for 'F219': "+ unionIndex219)); + } + } + int unionIndex220 = (decoder.readIndex()); + if (unionIndex220 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(220, null); + } else { + if (unionIndex220 == 1) { + Utf8 charSequence220; + Object oldString220 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(220); + if (oldString220 instanceof Utf8) { + charSequence220 = (decoder).readString(((Utf8) oldString220)); + } else { + charSequence220 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(220, charSequence220); + } else { + throw new RuntimeException(("Illegal union index for 'F220': "+ unionIndex220)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex221 = (decoder.readIndex()); + if (unionIndex221 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(221, null); + } else { + if (unionIndex221 == 1) { + Utf8 charSequence221; + Object oldString221 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(221); + if (oldString221 instanceof Utf8) { + charSequence221 = (decoder).readString(((Utf8) oldString221)); + } else { + charSequence221 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(221, charSequence221); + } else { + throw new RuntimeException(("Illegal union index for 'F221': "+ unionIndex221)); + } + } + int unionIndex222 = (decoder.readIndex()); + if (unionIndex222 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(222, null); + } else { + if (unionIndex222 == 1) { + Utf8 charSequence222; + Object oldString222 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(222); + if (oldString222 instanceof Utf8) { + charSequence222 = (decoder).readString(((Utf8) oldString222)); + } else { + charSequence222 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(222, charSequence222); + } else { + throw new RuntimeException(("Illegal union index for 'F222': "+ unionIndex222)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex223 = (decoder.readIndex()); + if (unionIndex223 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(223, null); + } else { + if (unionIndex223 == 1) { + Utf8 charSequence223; + Object oldString223 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(223); + if (oldString223 instanceof Utf8) { + charSequence223 = (decoder).readString(((Utf8) oldString223)); + } else { + charSequence223 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(223, charSequence223); + } else { + throw new RuntimeException(("Illegal union index for 'F223': "+ unionIndex223)); + } + } + int unionIndex224 = (decoder.readIndex()); + if (unionIndex224 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(224, null); + } else { + if (unionIndex224 == 1) { + Utf8 charSequence224; + Object oldString224 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(224); + if (oldString224 instanceof Utf8) { + charSequence224 = (decoder).readString(((Utf8) oldString224)); + } else { + charSequence224 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(224, charSequence224); + } else { + throw new RuntimeException(("Illegal union index for 'F224': "+ unionIndex224)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex225 = (decoder.readIndex()); + if (unionIndex225 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(225, null); + } else { + if (unionIndex225 == 1) { + Utf8 charSequence225; + Object oldString225 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(225); + if (oldString225 instanceof Utf8) { + charSequence225 = (decoder).readString(((Utf8) oldString225)); + } else { + charSequence225 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(225, charSequence225); + } else { + throw new RuntimeException(("Illegal union index for 'F225': "+ unionIndex225)); + } + } + int unionIndex226 = (decoder.readIndex()); + if (unionIndex226 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(226, null); + } else { + if (unionIndex226 == 1) { + Utf8 charSequence226; + Object oldString226 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(226); + if (oldString226 instanceof Utf8) { + charSequence226 = (decoder).readString(((Utf8) oldString226)); + } else { + charSequence226 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(226, charSequence226); + } else { + throw new RuntimeException(("Illegal union index for 'F226': "+ unionIndex226)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex227 = (decoder.readIndex()); + if (unionIndex227 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(227, null); + } else { + if (unionIndex227 == 1) { + Utf8 charSequence227; + Object oldString227 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(227); + if (oldString227 instanceof Utf8) { + charSequence227 = (decoder).readString(((Utf8) oldString227)); + } else { + charSequence227 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(227, charSequence227); + } else { + throw new RuntimeException(("Illegal union index for 'F227': "+ unionIndex227)); + } + } + int unionIndex228 = (decoder.readIndex()); + if (unionIndex228 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(228, null); + } else { + if (unionIndex228 == 1) { + Utf8 charSequence228; + Object oldString228 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(228); + if (oldString228 instanceof Utf8) { + charSequence228 = (decoder).readString(((Utf8) oldString228)); + } else { + charSequence228 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(228, charSequence228); + } else { + throw new RuntimeException(("Illegal union index for 'F228': "+ unionIndex228)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex229 = (decoder.readIndex()); + if (unionIndex229 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(229, null); + } else { + if (unionIndex229 == 1) { + Utf8 charSequence229; + Object oldString229 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(229); + if (oldString229 instanceof Utf8) { + charSequence229 = (decoder).readString(((Utf8) oldString229)); + } else { + charSequence229 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(229, charSequence229); + } else { + throw new RuntimeException(("Illegal union index for 'F229': "+ unionIndex229)); + } + } + int unionIndex230 = (decoder.readIndex()); + if (unionIndex230 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(230, null); + } else { + if (unionIndex230 == 1) { + Utf8 charSequence230; + Object oldString230 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(230); + if (oldString230 instanceof Utf8) { + charSequence230 = (decoder).readString(((Utf8) oldString230)); + } else { + charSequence230 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(230, charSequence230); + } else { + throw new RuntimeException(("Illegal union index for 'F230': "+ unionIndex230)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex231 = (decoder.readIndex()); + if (unionIndex231 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(231, null); + } else { + if (unionIndex231 == 1) { + Utf8 charSequence231; + Object oldString231 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(231); + if (oldString231 instanceof Utf8) { + charSequence231 = (decoder).readString(((Utf8) oldString231)); + } else { + charSequence231 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(231, charSequence231); + } else { + throw new RuntimeException(("Illegal union index for 'F231': "+ unionIndex231)); + } + } + int unionIndex232 = (decoder.readIndex()); + if (unionIndex232 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(232, null); + } else { + if (unionIndex232 == 1) { + Utf8 charSequence232; + Object oldString232 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(232); + if (oldString232 instanceof Utf8) { + charSequence232 = (decoder).readString(((Utf8) oldString232)); + } else { + charSequence232 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(232, charSequence232); + } else { + throw new RuntimeException(("Illegal union index for 'F232': "+ unionIndex232)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex233 = (decoder.readIndex()); + if (unionIndex233 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(233, null); + } else { + if (unionIndex233 == 1) { + Utf8 charSequence233; + Object oldString233 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(233); + if (oldString233 instanceof Utf8) { + charSequence233 = (decoder).readString(((Utf8) oldString233)); + } else { + charSequence233 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(233, charSequence233); + } else { + throw new RuntimeException(("Illegal union index for 'F233': "+ unionIndex233)); + } + } + int unionIndex234 = (decoder.readIndex()); + if (unionIndex234 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(234, null); + } else { + if (unionIndex234 == 1) { + Utf8 charSequence234; + Object oldString234 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(234); + if (oldString234 instanceof Utf8) { + charSequence234 = (decoder).readString(((Utf8) oldString234)); + } else { + charSequence234 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(234, charSequence234); + } else { + throw new RuntimeException(("Illegal union index for 'F234': "+ unionIndex234)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex235 = (decoder.readIndex()); + if (unionIndex235 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(235, null); + } else { + if (unionIndex235 == 1) { + Utf8 charSequence235; + Object oldString235 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(235); + if (oldString235 instanceof Utf8) { + charSequence235 = (decoder).readString(((Utf8) oldString235)); + } else { + charSequence235 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(235, charSequence235); + } else { + throw new RuntimeException(("Illegal union index for 'F235': "+ unionIndex235)); + } + } + int unionIndex236 = (decoder.readIndex()); + if (unionIndex236 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(236, null); + } else { + if (unionIndex236 == 1) { + Utf8 charSequence236; + Object oldString236 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(236); + if (oldString236 instanceof Utf8) { + charSequence236 = (decoder).readString(((Utf8) oldString236)); + } else { + charSequence236 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(236, charSequence236); + } else { + throw new RuntimeException(("Illegal union index for 'F236': "+ unionIndex236)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex237 = (decoder.readIndex()); + if (unionIndex237 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(237, null); + } else { + if (unionIndex237 == 1) { + Utf8 charSequence237; + Object oldString237 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(237); + if (oldString237 instanceof Utf8) { + charSequence237 = (decoder).readString(((Utf8) oldString237)); + } else { + charSequence237 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(237, charSequence237); + } else { + throw new RuntimeException(("Illegal union index for 'F237': "+ unionIndex237)); + } + } + int unionIndex238 = (decoder.readIndex()); + if (unionIndex238 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(238, null); + } else { + if (unionIndex238 == 1) { + Utf8 charSequence238; + Object oldString238 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(238); + if (oldString238 instanceof Utf8) { + charSequence238 = (decoder).readString(((Utf8) oldString238)); + } else { + charSequence238 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(238, charSequence238); + } else { + throw new RuntimeException(("Illegal union index for 'F238': "+ unionIndex238)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex239 = (decoder.readIndex()); + if (unionIndex239 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(239, null); + } else { + if (unionIndex239 == 1) { + Utf8 charSequence239; + Object oldString239 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(239); + if (oldString239 instanceof Utf8) { + charSequence239 = (decoder).readString(((Utf8) oldString239)); + } else { + charSequence239 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(239, charSequence239); + } else { + throw new RuntimeException(("Illegal union index for 'F239': "+ unionIndex239)); + } + } + int unionIndex240 = (decoder.readIndex()); + if (unionIndex240 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(240, null); + } else { + if (unionIndex240 == 1) { + Utf8 charSequence240; + Object oldString240 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(240); + if (oldString240 instanceof Utf8) { + charSequence240 = (decoder).readString(((Utf8) oldString240)); + } else { + charSequence240 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(240, charSequence240); + } else { + throw new RuntimeException(("Illegal union index for 'F240': "+ unionIndex240)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex241 = (decoder.readIndex()); + if (unionIndex241 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(241, null); + } else { + if (unionIndex241 == 1) { + Utf8 charSequence241; + Object oldString241 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(241); + if (oldString241 instanceof Utf8) { + charSequence241 = (decoder).readString(((Utf8) oldString241)); + } else { + charSequence241 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(241, charSequence241); + } else { + throw new RuntimeException(("Illegal union index for 'F241': "+ unionIndex241)); + } + } + int unionIndex242 = (decoder.readIndex()); + if (unionIndex242 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(242, null); + } else { + if (unionIndex242 == 1) { + Utf8 charSequence242; + Object oldString242 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(242); + if (oldString242 instanceof Utf8) { + charSequence242 = (decoder).readString(((Utf8) oldString242)); + } else { + charSequence242 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(242, charSequence242); + } else { + throw new RuntimeException(("Illegal union index for 'F242': "+ unionIndex242)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex243 = (decoder.readIndex()); + if (unionIndex243 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(243, null); + } else { + if (unionIndex243 == 1) { + Utf8 charSequence243; + Object oldString243 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(243); + if (oldString243 instanceof Utf8) { + charSequence243 = (decoder).readString(((Utf8) oldString243)); + } else { + charSequence243 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(243, charSequence243); + } else { + throw new RuntimeException(("Illegal union index for 'F243': "+ unionIndex243)); + } + } + int unionIndex244 = (decoder.readIndex()); + if (unionIndex244 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(244, null); + } else { + if (unionIndex244 == 1) { + Utf8 charSequence244; + Object oldString244 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(244); + if (oldString244 instanceof Utf8) { + charSequence244 = (decoder).readString(((Utf8) oldString244)); + } else { + charSequence244 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(244, charSequence244); + } else { + throw new RuntimeException(("Illegal union index for 'F244': "+ unionIndex244)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex245 = (decoder.readIndex()); + if (unionIndex245 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(245, null); + } else { + if (unionIndex245 == 1) { + Utf8 charSequence245; + Object oldString245 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(245); + if (oldString245 instanceof Utf8) { + charSequence245 = (decoder).readString(((Utf8) oldString245)); + } else { + charSequence245 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(245, charSequence245); + } else { + throw new RuntimeException(("Illegal union index for 'F245': "+ unionIndex245)); + } + } + int unionIndex246 = (decoder.readIndex()); + if (unionIndex246 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(246, null); + } else { + if (unionIndex246 == 1) { + Utf8 charSequence246; + Object oldString246 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(246); + if (oldString246 instanceof Utf8) { + charSequence246 = (decoder).readString(((Utf8) oldString246)); + } else { + charSequence246 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(246, charSequence246); + } else { + throw new RuntimeException(("Illegal union index for 'F246': "+ unionIndex246)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex247 = (decoder.readIndex()); + if (unionIndex247 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(247, null); + } else { + if (unionIndex247 == 1) { + Utf8 charSequence247; + Object oldString247 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(247); + if (oldString247 instanceof Utf8) { + charSequence247 = (decoder).readString(((Utf8) oldString247)); + } else { + charSequence247 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(247, charSequence247); + } else { + throw new RuntimeException(("Illegal union index for 'F247': "+ unionIndex247)); + } + } + int unionIndex248 = (decoder.readIndex()); + if (unionIndex248 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(248, null); + } else { + if (unionIndex248 == 1) { + Utf8 charSequence248; + Object oldString248 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(248); + if (oldString248 instanceof Utf8) { + charSequence248 = (decoder).readString(((Utf8) oldString248)); + } else { + charSequence248 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(248, charSequence248); + } else { + throw new RuntimeException(("Illegal union index for 'F248': "+ unionIndex248)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex249 = (decoder.readIndex()); + if (unionIndex249 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(249, null); + } else { + if (unionIndex249 == 1) { + Utf8 charSequence249; + Object oldString249 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(249); + if (oldString249 instanceof Utf8) { + charSequence249 = (decoder).readString(((Utf8) oldString249)); + } else { + charSequence249 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(249, charSequence249); + } else { + throw new RuntimeException(("Illegal union index for 'F249': "+ unionIndex249)); + } + } + int unionIndex250 = (decoder.readIndex()); + if (unionIndex250 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(250, null); + } else { + if (unionIndex250 == 1) { + Utf8 charSequence250; + Object oldString250 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(250); + if (oldString250 instanceof Utf8) { + charSequence250 = (decoder).readString(((Utf8) oldString250)); + } else { + charSequence250 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(250, charSequence250); + } else { + throw new RuntimeException(("Illegal union index for 'F250': "+ unionIndex250)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex251 = (decoder.readIndex()); + if (unionIndex251 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(251, null); + } else { + if (unionIndex251 == 1) { + Utf8 charSequence251; + Object oldString251 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(251); + if (oldString251 instanceof Utf8) { + charSequence251 = (decoder).readString(((Utf8) oldString251)); + } else { + charSequence251 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(251, charSequence251); + } else { + throw new RuntimeException(("Illegal union index for 'F251': "+ unionIndex251)); + } + } + int unionIndex252 = (decoder.readIndex()); + if (unionIndex252 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(252, null); + } else { + if (unionIndex252 == 1) { + Utf8 charSequence252; + Object oldString252 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(252); + if (oldString252 instanceof Utf8) { + charSequence252 = (decoder).readString(((Utf8) oldString252)); + } else { + charSequence252 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(252, charSequence252); + } else { + throw new RuntimeException(("Illegal union index for 'F252': "+ unionIndex252)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex253 = (decoder.readIndex()); + if (unionIndex253 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(253, null); + } else { + if (unionIndex253 == 1) { + Utf8 charSequence253; + Object oldString253 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(253); + if (oldString253 instanceof Utf8) { + charSequence253 = (decoder).readString(((Utf8) oldString253)); + } else { + charSequence253 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(253, charSequence253); + } else { + throw new RuntimeException(("Illegal union index for 'F253': "+ unionIndex253)); + } + } + int unionIndex254 = (decoder.readIndex()); + if (unionIndex254 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(254, null); + } else { + if (unionIndex254 == 1) { + Utf8 charSequence254; + Object oldString254 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(254); + if (oldString254 instanceof Utf8) { + charSequence254 = (decoder).readString(((Utf8) oldString254)); + } else { + charSequence254 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(254, charSequence254); + } else { + throw new RuntimeException(("Illegal union index for 'F254': "+ unionIndex254)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex255 = (decoder.readIndex()); + if (unionIndex255 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(255, null); + } else { + if (unionIndex255 == 1) { + Utf8 charSequence255; + Object oldString255 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(255); + if (oldString255 instanceof Utf8) { + charSequence255 = (decoder).readString(((Utf8) oldString255)); + } else { + charSequence255 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(255, charSequence255); + } else { + throw new RuntimeException(("Illegal union index for 'F255': "+ unionIndex255)); + } + } + int unionIndex256 = (decoder.readIndex()); + if (unionIndex256 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(256, null); + } else { + if (unionIndex256 == 1) { + Utf8 charSequence256; + Object oldString256 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(256); + if (oldString256 instanceof Utf8) { + charSequence256 = (decoder).readString(((Utf8) oldString256)); + } else { + charSequence256 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(256, charSequence256); + } else { + throw new RuntimeException(("Illegal union index for 'F256': "+ unionIndex256)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex257 = (decoder.readIndex()); + if (unionIndex257 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(257, null); + } else { + if (unionIndex257 == 1) { + Utf8 charSequence257; + Object oldString257 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(257); + if (oldString257 instanceof Utf8) { + charSequence257 = (decoder).readString(((Utf8) oldString257)); + } else { + charSequence257 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(257, charSequence257); + } else { + throw new RuntimeException(("Illegal union index for 'F257': "+ unionIndex257)); + } + } + int unionIndex258 = (decoder.readIndex()); + if (unionIndex258 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(258, null); + } else { + if (unionIndex258 == 1) { + Utf8 charSequence258; + Object oldString258 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(258); + if (oldString258 instanceof Utf8) { + charSequence258 = (decoder).readString(((Utf8) oldString258)); + } else { + charSequence258 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(258, charSequence258); + } else { + throw new RuntimeException(("Illegal union index for 'F258': "+ unionIndex258)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex259 = (decoder.readIndex()); + if (unionIndex259 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(259, null); + } else { + if (unionIndex259 == 1) { + Utf8 charSequence259; + Object oldString259 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(259); + if (oldString259 instanceof Utf8) { + charSequence259 = (decoder).readString(((Utf8) oldString259)); + } else { + charSequence259 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(259, charSequence259); + } else { + throw new RuntimeException(("Illegal union index for 'F259': "+ unionIndex259)); + } + } + int unionIndex260 = (decoder.readIndex()); + if (unionIndex260 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(260, null); + } else { + if (unionIndex260 == 1) { + Utf8 charSequence260; + Object oldString260 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(260); + if (oldString260 instanceof Utf8) { + charSequence260 = (decoder).readString(((Utf8) oldString260)); + } else { + charSequence260 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(260, charSequence260); + } else { + throw new RuntimeException(("Illegal union index for 'F260': "+ unionIndex260)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex261 = (decoder.readIndex()); + if (unionIndex261 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(261, null); + } else { + if (unionIndex261 == 1) { + Utf8 charSequence261; + Object oldString261 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(261); + if (oldString261 instanceof Utf8) { + charSequence261 = (decoder).readString(((Utf8) oldString261)); + } else { + charSequence261 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(261, charSequence261); + } else { + throw new RuntimeException(("Illegal union index for 'F261': "+ unionIndex261)); + } + } + int unionIndex262 = (decoder.readIndex()); + if (unionIndex262 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(262, null); + } else { + if (unionIndex262 == 1) { + Utf8 charSequence262; + Object oldString262 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(262); + if (oldString262 instanceof Utf8) { + charSequence262 = (decoder).readString(((Utf8) oldString262)); + } else { + charSequence262 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(262, charSequence262); + } else { + throw new RuntimeException(("Illegal union index for 'F262': "+ unionIndex262)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex263 = (decoder.readIndex()); + if (unionIndex263 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(263, null); + } else { + if (unionIndex263 == 1) { + Utf8 charSequence263; + Object oldString263 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(263); + if (oldString263 instanceof Utf8) { + charSequence263 = (decoder).readString(((Utf8) oldString263)); + } else { + charSequence263 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(263, charSequence263); + } else { + throw new RuntimeException(("Illegal union index for 'F263': "+ unionIndex263)); + } + } + int unionIndex264 = (decoder.readIndex()); + if (unionIndex264 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(264, null); + } else { + if (unionIndex264 == 1) { + Utf8 charSequence264; + Object oldString264 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(264); + if (oldString264 instanceof Utf8) { + charSequence264 = (decoder).readString(((Utf8) oldString264)); + } else { + charSequence264 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(264, charSequence264); + } else { + throw new RuntimeException(("Illegal union index for 'F264': "+ unionIndex264)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex265 = (decoder.readIndex()); + if (unionIndex265 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(265, null); + } else { + if (unionIndex265 == 1) { + Utf8 charSequence265; + Object oldString265 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(265); + if (oldString265 instanceof Utf8) { + charSequence265 = (decoder).readString(((Utf8) oldString265)); + } else { + charSequence265 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(265, charSequence265); + } else { + throw new RuntimeException(("Illegal union index for 'F265': "+ unionIndex265)); + } + } + int unionIndex266 = (decoder.readIndex()); + if (unionIndex266 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(266, null); + } else { + if (unionIndex266 == 1) { + Utf8 charSequence266; + Object oldString266 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(266); + if (oldString266 instanceof Utf8) { + charSequence266 = (decoder).readString(((Utf8) oldString266)); + } else { + charSequence266 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(266, charSequence266); + } else { + throw new RuntimeException(("Illegal union index for 'F266': "+ unionIndex266)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex267 = (decoder.readIndex()); + if (unionIndex267 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(267, null); + } else { + if (unionIndex267 == 1) { + Utf8 charSequence267; + Object oldString267 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(267); + if (oldString267 instanceof Utf8) { + charSequence267 = (decoder).readString(((Utf8) oldString267)); + } else { + charSequence267 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(267, charSequence267); + } else { + throw new RuntimeException(("Illegal union index for 'F267': "+ unionIndex267)); + } + } + int unionIndex268 = (decoder.readIndex()); + if (unionIndex268 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(268, null); + } else { + if (unionIndex268 == 1) { + Utf8 charSequence268; + Object oldString268 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(268); + if (oldString268 instanceof Utf8) { + charSequence268 = (decoder).readString(((Utf8) oldString268)); + } else { + charSequence268 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(268, charSequence268); + } else { + throw new RuntimeException(("Illegal union index for 'F268': "+ unionIndex268)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex269 = (decoder.readIndex()); + if (unionIndex269 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(269, null); + } else { + if (unionIndex269 == 1) { + Utf8 charSequence269; + Object oldString269 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(269); + if (oldString269 instanceof Utf8) { + charSequence269 = (decoder).readString(((Utf8) oldString269)); + } else { + charSequence269 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(269, charSequence269); + } else { + throw new RuntimeException(("Illegal union index for 'F269': "+ unionIndex269)); + } + } + int unionIndex270 = (decoder.readIndex()); + if (unionIndex270 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(270, null); + } else { + if (unionIndex270 == 1) { + Utf8 charSequence270; + Object oldString270 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(270); + if (oldString270 instanceof Utf8) { + charSequence270 = (decoder).readString(((Utf8) oldString270)); + } else { + charSequence270 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(270, charSequence270); + } else { + throw new RuntimeException(("Illegal union index for 'F270': "+ unionIndex270)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex271 = (decoder.readIndex()); + if (unionIndex271 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(271, null); + } else { + if (unionIndex271 == 1) { + Utf8 charSequence271; + Object oldString271 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(271); + if (oldString271 instanceof Utf8) { + charSequence271 = (decoder).readString(((Utf8) oldString271)); + } else { + charSequence271 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(271, charSequence271); + } else { + throw new RuntimeException(("Illegal union index for 'F271': "+ unionIndex271)); + } + } + int unionIndex272 = (decoder.readIndex()); + if (unionIndex272 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(272, null); + } else { + if (unionIndex272 == 1) { + Utf8 charSequence272; + Object oldString272 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(272); + if (oldString272 instanceof Utf8) { + charSequence272 = (decoder).readString(((Utf8) oldString272)); + } else { + charSequence272 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(272, charSequence272); + } else { + throw new RuntimeException(("Illegal union index for 'F272': "+ unionIndex272)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex273 = (decoder.readIndex()); + if (unionIndex273 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(273, null); + } else { + if (unionIndex273 == 1) { + Utf8 charSequence273; + Object oldString273 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(273); + if (oldString273 instanceof Utf8) { + charSequence273 = (decoder).readString(((Utf8) oldString273)); + } else { + charSequence273 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(273, charSequence273); + } else { + throw new RuntimeException(("Illegal union index for 'F273': "+ unionIndex273)); + } + } + int unionIndex274 = (decoder.readIndex()); + if (unionIndex274 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(274, null); + } else { + if (unionIndex274 == 1) { + Utf8 charSequence274; + Object oldString274 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(274); + if (oldString274 instanceof Utf8) { + charSequence274 = (decoder).readString(((Utf8) oldString274)); + } else { + charSequence274 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(274, charSequence274); + } else { + throw new RuntimeException(("Illegal union index for 'F274': "+ unionIndex274)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex275 = (decoder.readIndex()); + if (unionIndex275 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(275, null); + } else { + if (unionIndex275 == 1) { + Utf8 charSequence275; + Object oldString275 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(275); + if (oldString275 instanceof Utf8) { + charSequence275 = (decoder).readString(((Utf8) oldString275)); + } else { + charSequence275 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(275, charSequence275); + } else { + throw new RuntimeException(("Illegal union index for 'F275': "+ unionIndex275)); + } + } + int unionIndex276 = (decoder.readIndex()); + if (unionIndex276 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(276, null); + } else { + if (unionIndex276 == 1) { + Utf8 charSequence276; + Object oldString276 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(276); + if (oldString276 instanceof Utf8) { + charSequence276 = (decoder).readString(((Utf8) oldString276)); + } else { + charSequence276 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(276, charSequence276); + } else { + throw new RuntimeException(("Illegal union index for 'F276': "+ unionIndex276)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex277 = (decoder.readIndex()); + if (unionIndex277 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(277, null); + } else { + if (unionIndex277 == 1) { + Utf8 charSequence277; + Object oldString277 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(277); + if (oldString277 instanceof Utf8) { + charSequence277 = (decoder).readString(((Utf8) oldString277)); + } else { + charSequence277 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(277, charSequence277); + } else { + throw new RuntimeException(("Illegal union index for 'F277': "+ unionIndex277)); + } + } + int unionIndex278 = (decoder.readIndex()); + if (unionIndex278 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(278, null); + } else { + if (unionIndex278 == 1) { + Utf8 charSequence278; + Object oldString278 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(278); + if (oldString278 instanceof Utf8) { + charSequence278 = (decoder).readString(((Utf8) oldString278)); + } else { + charSequence278 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(278, charSequence278); + } else { + throw new RuntimeException(("Illegal union index for 'F278': "+ unionIndex278)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex279 = (decoder.readIndex()); + if (unionIndex279 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(279, null); + } else { + if (unionIndex279 == 1) { + Utf8 charSequence279; + Object oldString279 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(279); + if (oldString279 instanceof Utf8) { + charSequence279 = (decoder).readString(((Utf8) oldString279)); + } else { + charSequence279 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(279, charSequence279); + } else { + throw new RuntimeException(("Illegal union index for 'F279': "+ unionIndex279)); + } + } + int unionIndex280 = (decoder.readIndex()); + if (unionIndex280 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(280, null); + } else { + if (unionIndex280 == 1) { + Utf8 charSequence280; + Object oldString280 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(280); + if (oldString280 instanceof Utf8) { + charSequence280 = (decoder).readString(((Utf8) oldString280)); + } else { + charSequence280 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(280, charSequence280); + } else { + throw new RuntimeException(("Illegal union index for 'F280': "+ unionIndex280)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex281 = (decoder.readIndex()); + if (unionIndex281 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(281, null); + } else { + if (unionIndex281 == 1) { + Utf8 charSequence281; + Object oldString281 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(281); + if (oldString281 instanceof Utf8) { + charSequence281 = (decoder).readString(((Utf8) oldString281)); + } else { + charSequence281 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(281, charSequence281); + } else { + throw new RuntimeException(("Illegal union index for 'F281': "+ unionIndex281)); + } + } + int unionIndex282 = (decoder.readIndex()); + if (unionIndex282 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(282, null); + } else { + if (unionIndex282 == 1) { + Utf8 charSequence282; + Object oldString282 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(282); + if (oldString282 instanceof Utf8) { + charSequence282 = (decoder).readString(((Utf8) oldString282)); + } else { + charSequence282 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(282, charSequence282); + } else { + throw new RuntimeException(("Illegal union index for 'F282': "+ unionIndex282)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex283 = (decoder.readIndex()); + if (unionIndex283 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(283, null); + } else { + if (unionIndex283 == 1) { + Utf8 charSequence283; + Object oldString283 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(283); + if (oldString283 instanceof Utf8) { + charSequence283 = (decoder).readString(((Utf8) oldString283)); + } else { + charSequence283 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(283, charSequence283); + } else { + throw new RuntimeException(("Illegal union index for 'F283': "+ unionIndex283)); + } + } + int unionIndex284 = (decoder.readIndex()); + if (unionIndex284 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(284, null); + } else { + if (unionIndex284 == 1) { + Utf8 charSequence284; + Object oldString284 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(284); + if (oldString284 instanceof Utf8) { + charSequence284 = (decoder).readString(((Utf8) oldString284)); + } else { + charSequence284 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(284, charSequence284); + } else { + throw new RuntimeException(("Illegal union index for 'F284': "+ unionIndex284)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex285 = (decoder.readIndex()); + if (unionIndex285 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(285, null); + } else { + if (unionIndex285 == 1) { + Utf8 charSequence285; + Object oldString285 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(285); + if (oldString285 instanceof Utf8) { + charSequence285 = (decoder).readString(((Utf8) oldString285)); + } else { + charSequence285 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(285, charSequence285); + } else { + throw new RuntimeException(("Illegal union index for 'F285': "+ unionIndex285)); + } + } + int unionIndex286 = (decoder.readIndex()); + if (unionIndex286 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(286, null); + } else { + if (unionIndex286 == 1) { + Utf8 charSequence286; + Object oldString286 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(286); + if (oldString286 instanceof Utf8) { + charSequence286 = (decoder).readString(((Utf8) oldString286)); + } else { + charSequence286 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(286, charSequence286); + } else { + throw new RuntimeException(("Illegal union index for 'F286': "+ unionIndex286)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex287 = (decoder.readIndex()); + if (unionIndex287 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(287, null); + } else { + if (unionIndex287 == 1) { + Utf8 charSequence287; + Object oldString287 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(287); + if (oldString287 instanceof Utf8) { + charSequence287 = (decoder).readString(((Utf8) oldString287)); + } else { + charSequence287 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(287, charSequence287); + } else { + throw new RuntimeException(("Illegal union index for 'F287': "+ unionIndex287)); + } + } + int unionIndex288 = (decoder.readIndex()); + if (unionIndex288 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(288, null); + } else { + if (unionIndex288 == 1) { + Utf8 charSequence288; + Object oldString288 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(288); + if (oldString288 instanceof Utf8) { + charSequence288 = (decoder).readString(((Utf8) oldString288)); + } else { + charSequence288 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(288, charSequence288); + } else { + throw new RuntimeException(("Illegal union index for 'F288': "+ unionIndex288)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex289 = (decoder.readIndex()); + if (unionIndex289 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(289, null); + } else { + if (unionIndex289 == 1) { + Utf8 charSequence289; + Object oldString289 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(289); + if (oldString289 instanceof Utf8) { + charSequence289 = (decoder).readString(((Utf8) oldString289)); + } else { + charSequence289 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(289, charSequence289); + } else { + throw new RuntimeException(("Illegal union index for 'F289': "+ unionIndex289)); + } + } + int unionIndex290 = (decoder.readIndex()); + if (unionIndex290 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(290, null); + } else { + if (unionIndex290 == 1) { + Utf8 charSequence290; + Object oldString290 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(290); + if (oldString290 instanceof Utf8) { + charSequence290 = (decoder).readString(((Utf8) oldString290)); + } else { + charSequence290 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(290, charSequence290); + } else { + throw new RuntimeException(("Illegal union index for 'F290': "+ unionIndex290)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex291 = (decoder.readIndex()); + if (unionIndex291 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(291, null); + } else { + if (unionIndex291 == 1) { + Utf8 charSequence291; + Object oldString291 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(291); + if (oldString291 instanceof Utf8) { + charSequence291 = (decoder).readString(((Utf8) oldString291)); + } else { + charSequence291 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(291, charSequence291); + } else { + throw new RuntimeException(("Illegal union index for 'F291': "+ unionIndex291)); + } + } + int unionIndex292 = (decoder.readIndex()); + if (unionIndex292 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(292, null); + } else { + if (unionIndex292 == 1) { + Utf8 charSequence292; + Object oldString292 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(292); + if (oldString292 instanceof Utf8) { + charSequence292 = (decoder).readString(((Utf8) oldString292)); + } else { + charSequence292 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(292, charSequence292); + } else { + throw new RuntimeException(("Illegal union index for 'F292': "+ unionIndex292)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex293 = (decoder.readIndex()); + if (unionIndex293 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(293, null); + } else { + if (unionIndex293 == 1) { + Utf8 charSequence293; + Object oldString293 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(293); + if (oldString293 instanceof Utf8) { + charSequence293 = (decoder).readString(((Utf8) oldString293)); + } else { + charSequence293 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(293, charSequence293); + } else { + throw new RuntimeException(("Illegal union index for 'F293': "+ unionIndex293)); + } + } + int unionIndex294 = (decoder.readIndex()); + if (unionIndex294 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(294, null); + } else { + if (unionIndex294 == 1) { + Utf8 charSequence294; + Object oldString294 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(294); + if (oldString294 instanceof Utf8) { + charSequence294 = (decoder).readString(((Utf8) oldString294)); + } else { + charSequence294 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(294, charSequence294); + } else { + throw new RuntimeException(("Illegal union index for 'F294': "+ unionIndex294)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex295 = (decoder.readIndex()); + if (unionIndex295 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(295, null); + } else { + if (unionIndex295 == 1) { + Utf8 charSequence295; + Object oldString295 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(295); + if (oldString295 instanceof Utf8) { + charSequence295 = (decoder).readString(((Utf8) oldString295)); + } else { + charSequence295 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(295, charSequence295); + } else { + throw new RuntimeException(("Illegal union index for 'F295': "+ unionIndex295)); + } + } + int unionIndex296 = (decoder.readIndex()); + if (unionIndex296 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(296, null); + } else { + if (unionIndex296 == 1) { + Utf8 charSequence296; + Object oldString296 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(296); + if (oldString296 instanceof Utf8) { + charSequence296 = (decoder).readString(((Utf8) oldString296)); + } else { + charSequence296 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(296, charSequence296); + } else { + throw new RuntimeException(("Illegal union index for 'F296': "+ unionIndex296)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex297 = (decoder.readIndex()); + if (unionIndex297 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(297, null); + } else { + if (unionIndex297 == 1) { + Utf8 charSequence297; + Object oldString297 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(297); + if (oldString297 instanceof Utf8) { + charSequence297 = (decoder).readString(((Utf8) oldString297)); + } else { + charSequence297 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(297, charSequence297); + } else { + throw new RuntimeException(("Illegal union index for 'F297': "+ unionIndex297)); + } + } + int unionIndex298 = (decoder.readIndex()); + if (unionIndex298 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(298, null); + } else { + if (unionIndex298 == 1) { + Utf8 charSequence298; + Object oldString298 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(298); + if (oldString298 instanceof Utf8) { + charSequence298 = (decoder).readString(((Utf8) oldString298)); + } else { + charSequence298 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(298, charSequence298); + } else { + throw new RuntimeException(("Illegal union index for 'F298': "+ unionIndex298)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex299 = (decoder.readIndex()); + if (unionIndex299 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(299, null); + } else { + if (unionIndex299 == 1) { + Utf8 charSequence299; + Object oldString299 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(299); + if (oldString299 instanceof Utf8) { + charSequence299 = (decoder).readString(((Utf8) oldString299)); + } else { + charSequence299 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(299, charSequence299); + } else { + throw new RuntimeException(("Illegal union index for 'F299': "+ unionIndex299)); + } + } + int unionIndex300 = (decoder.readIndex()); + if (unionIndex300 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(300, null); + } else { + if (unionIndex300 == 1) { + Utf8 charSequence300; + Object oldString300 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(300); + if (oldString300 instanceof Utf8) { + charSequence300 = (decoder).readString(((Utf8) oldString300)); + } else { + charSequence300 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(300, charSequence300); + } else { + throw new RuntimeException(("Illegal union index for 'F300': "+ unionIndex300)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex301 = (decoder.readIndex()); + if (unionIndex301 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(301, null); + } else { + if (unionIndex301 == 1) { + Utf8 charSequence301; + Object oldString301 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(301); + if (oldString301 instanceof Utf8) { + charSequence301 = (decoder).readString(((Utf8) oldString301)); + } else { + charSequence301 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(301, charSequence301); + } else { + throw new RuntimeException(("Illegal union index for 'F301': "+ unionIndex301)); + } + } + int unionIndex302 = (decoder.readIndex()); + if (unionIndex302 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(302, null); + } else { + if (unionIndex302 == 1) { + Utf8 charSequence302; + Object oldString302 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(302); + if (oldString302 instanceof Utf8) { + charSequence302 = (decoder).readString(((Utf8) oldString302)); + } else { + charSequence302 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(302, charSequence302); + } else { + throw new RuntimeException(("Illegal union index for 'F302': "+ unionIndex302)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex303 = (decoder.readIndex()); + if (unionIndex303 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(303, null); + } else { + if (unionIndex303 == 1) { + Utf8 charSequence303; + Object oldString303 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(303); + if (oldString303 instanceof Utf8) { + charSequence303 = (decoder).readString(((Utf8) oldString303)); + } else { + charSequence303 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(303, charSequence303); + } else { + throw new RuntimeException(("Illegal union index for 'F303': "+ unionIndex303)); + } + } + int unionIndex304 = (decoder.readIndex()); + if (unionIndex304 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(304, null); + } else { + if (unionIndex304 == 1) { + Utf8 charSequence304; + Object oldString304 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(304); + if (oldString304 instanceof Utf8) { + charSequence304 = (decoder).readString(((Utf8) oldString304)); + } else { + charSequence304 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(304, charSequence304); + } else { + throw new RuntimeException(("Illegal union index for 'F304': "+ unionIndex304)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex305 = (decoder.readIndex()); + if (unionIndex305 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(305, null); + } else { + if (unionIndex305 == 1) { + Utf8 charSequence305; + Object oldString305 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(305); + if (oldString305 instanceof Utf8) { + charSequence305 = (decoder).readString(((Utf8) oldString305)); + } else { + charSequence305 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(305, charSequence305); + } else { + throw new RuntimeException(("Illegal union index for 'F305': "+ unionIndex305)); + } + } + int unionIndex306 = (decoder.readIndex()); + if (unionIndex306 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(306, null); + } else { + if (unionIndex306 == 1) { + Utf8 charSequence306; + Object oldString306 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(306); + if (oldString306 instanceof Utf8) { + charSequence306 = (decoder).readString(((Utf8) oldString306)); + } else { + charSequence306 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(306, charSequence306); + } else { + throw new RuntimeException(("Illegal union index for 'F306': "+ unionIndex306)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex307 = (decoder.readIndex()); + if (unionIndex307 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(307, null); + } else { + if (unionIndex307 == 1) { + Utf8 charSequence307; + Object oldString307 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(307); + if (oldString307 instanceof Utf8) { + charSequence307 = (decoder).readString(((Utf8) oldString307)); + } else { + charSequence307 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(307, charSequence307); + } else { + throw new RuntimeException(("Illegal union index for 'F307': "+ unionIndex307)); + } + } + int unionIndex308 = (decoder.readIndex()); + if (unionIndex308 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(308, null); + } else { + if (unionIndex308 == 1) { + Utf8 charSequence308; + Object oldString308 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(308); + if (oldString308 instanceof Utf8) { + charSequence308 = (decoder).readString(((Utf8) oldString308)); + } else { + charSequence308 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(308, charSequence308); + } else { + throw new RuntimeException(("Illegal union index for 'F308': "+ unionIndex308)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex309 = (decoder.readIndex()); + if (unionIndex309 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(309, null); + } else { + if (unionIndex309 == 1) { + Utf8 charSequence309; + Object oldString309 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(309); + if (oldString309 instanceof Utf8) { + charSequence309 = (decoder).readString(((Utf8) oldString309)); + } else { + charSequence309 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(309, charSequence309); + } else { + throw new RuntimeException(("Illegal union index for 'F309': "+ unionIndex309)); + } + } + int unionIndex310 = (decoder.readIndex()); + if (unionIndex310 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(310, null); + } else { + if (unionIndex310 == 1) { + Utf8 charSequence310; + Object oldString310 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(310); + if (oldString310 instanceof Utf8) { + charSequence310 = (decoder).readString(((Utf8) oldString310)); + } else { + charSequence310 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(310, charSequence310); + } else { + throw new RuntimeException(("Illegal union index for 'F310': "+ unionIndex310)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex311 = (decoder.readIndex()); + if (unionIndex311 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(311, null); + } else { + if (unionIndex311 == 1) { + Utf8 charSequence311; + Object oldString311 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(311); + if (oldString311 instanceof Utf8) { + charSequence311 = (decoder).readString(((Utf8) oldString311)); + } else { + charSequence311 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(311, charSequence311); + } else { + throw new RuntimeException(("Illegal union index for 'F311': "+ unionIndex311)); + } + } + int unionIndex312 = (decoder.readIndex()); + if (unionIndex312 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(312, null); + } else { + if (unionIndex312 == 1) { + Utf8 charSequence312; + Object oldString312 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(312); + if (oldString312 instanceof Utf8) { + charSequence312 = (decoder).readString(((Utf8) oldString312)); + } else { + charSequence312 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(312, charSequence312); + } else { + throw new RuntimeException(("Illegal union index for 'F312': "+ unionIndex312)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex313 = (decoder.readIndex()); + if (unionIndex313 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(313, null); + } else { + if (unionIndex313 == 1) { + Utf8 charSequence313; + Object oldString313 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(313); + if (oldString313 instanceof Utf8) { + charSequence313 = (decoder).readString(((Utf8) oldString313)); + } else { + charSequence313 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(313, charSequence313); + } else { + throw new RuntimeException(("Illegal union index for 'F313': "+ unionIndex313)); + } + } + int unionIndex314 = (decoder.readIndex()); + if (unionIndex314 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(314, null); + } else { + if (unionIndex314 == 1) { + Utf8 charSequence314; + Object oldString314 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(314); + if (oldString314 instanceof Utf8) { + charSequence314 = (decoder).readString(((Utf8) oldString314)); + } else { + charSequence314 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(314, charSequence314); + } else { + throw new RuntimeException(("Illegal union index for 'F314': "+ unionIndex314)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex315 = (decoder.readIndex()); + if (unionIndex315 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(315, null); + } else { + if (unionIndex315 == 1) { + Utf8 charSequence315; + Object oldString315 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(315); + if (oldString315 instanceof Utf8) { + charSequence315 = (decoder).readString(((Utf8) oldString315)); + } else { + charSequence315 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(315, charSequence315); + } else { + throw new RuntimeException(("Illegal union index for 'F315': "+ unionIndex315)); + } + } + int unionIndex316 = (decoder.readIndex()); + if (unionIndex316 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(316, null); + } else { + if (unionIndex316 == 1) { + Utf8 charSequence316; + Object oldString316 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(316); + if (oldString316 instanceof Utf8) { + charSequence316 = (decoder).readString(((Utf8) oldString316)); + } else { + charSequence316 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(316, charSequence316); + } else { + throw new RuntimeException(("Illegal union index for 'F316': "+ unionIndex316)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex317 = (decoder.readIndex()); + if (unionIndex317 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(317, null); + } else { + if (unionIndex317 == 1) { + Utf8 charSequence317; + Object oldString317 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(317); + if (oldString317 instanceof Utf8) { + charSequence317 = (decoder).readString(((Utf8) oldString317)); + } else { + charSequence317 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(317, charSequence317); + } else { + throw new RuntimeException(("Illegal union index for 'F317': "+ unionIndex317)); + } + } + int unionIndex318 = (decoder.readIndex()); + if (unionIndex318 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(318, null); + } else { + if (unionIndex318 == 1) { + Utf8 charSequence318; + Object oldString318 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(318); + if (oldString318 instanceof Utf8) { + charSequence318 = (decoder).readString(((Utf8) oldString318)); + } else { + charSequence318 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(318, charSequence318); + } else { + throw new RuntimeException(("Illegal union index for 'F318': "+ unionIndex318)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex319 = (decoder.readIndex()); + if (unionIndex319 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(319, null); + } else { + if (unionIndex319 == 1) { + Utf8 charSequence319; + Object oldString319 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(319); + if (oldString319 instanceof Utf8) { + charSequence319 = (decoder).readString(((Utf8) oldString319)); + } else { + charSequence319 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(319, charSequence319); + } else { + throw new RuntimeException(("Illegal union index for 'F319': "+ unionIndex319)); + } + } + int unionIndex320 = (decoder.readIndex()); + if (unionIndex320 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(320, null); + } else { + if (unionIndex320 == 1) { + Utf8 charSequence320; + Object oldString320 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(320); + if (oldString320 instanceof Utf8) { + charSequence320 = (decoder).readString(((Utf8) oldString320)); + } else { + charSequence320 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(320, charSequence320); + } else { + throw new RuntimeException(("Illegal union index for 'F320': "+ unionIndex320)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex321 = (decoder.readIndex()); + if (unionIndex321 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(321, null); + } else { + if (unionIndex321 == 1) { + Utf8 charSequence321; + Object oldString321 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(321); + if (oldString321 instanceof Utf8) { + charSequence321 = (decoder).readString(((Utf8) oldString321)); + } else { + charSequence321 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(321, charSequence321); + } else { + throw new RuntimeException(("Illegal union index for 'F321': "+ unionIndex321)); + } + } + int unionIndex322 = (decoder.readIndex()); + if (unionIndex322 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(322, null); + } else { + if (unionIndex322 == 1) { + Utf8 charSequence322; + Object oldString322 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(322); + if (oldString322 instanceof Utf8) { + charSequence322 = (decoder).readString(((Utf8) oldString322)); + } else { + charSequence322 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(322, charSequence322); + } else { + throw new RuntimeException(("Illegal union index for 'F322': "+ unionIndex322)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex323 = (decoder.readIndex()); + if (unionIndex323 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(323, null); + } else { + if (unionIndex323 == 1) { + Utf8 charSequence323; + Object oldString323 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(323); + if (oldString323 instanceof Utf8) { + charSequence323 = (decoder).readString(((Utf8) oldString323)); + } else { + charSequence323 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(323, charSequence323); + } else { + throw new RuntimeException(("Illegal union index for 'F323': "+ unionIndex323)); + } + } + int unionIndex324 = (decoder.readIndex()); + if (unionIndex324 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(324, null); + } else { + if (unionIndex324 == 1) { + Utf8 charSequence324; + Object oldString324 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(324); + if (oldString324 instanceof Utf8) { + charSequence324 = (decoder).readString(((Utf8) oldString324)); + } else { + charSequence324 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(324, charSequence324); + } else { + throw new RuntimeException(("Illegal union index for 'F324': "+ unionIndex324)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex325 = (decoder.readIndex()); + if (unionIndex325 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(325, null); + } else { + if (unionIndex325 == 1) { + Utf8 charSequence325; + Object oldString325 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(325); + if (oldString325 instanceof Utf8) { + charSequence325 = (decoder).readString(((Utf8) oldString325)); + } else { + charSequence325 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(325, charSequence325); + } else { + throw new RuntimeException(("Illegal union index for 'F325': "+ unionIndex325)); + } + } + int unionIndex326 = (decoder.readIndex()); + if (unionIndex326 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(326, null); + } else { + if (unionIndex326 == 1) { + Utf8 charSequence326; + Object oldString326 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(326); + if (oldString326 instanceof Utf8) { + charSequence326 = (decoder).readString(((Utf8) oldString326)); + } else { + charSequence326 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(326, charSequence326); + } else { + throw new RuntimeException(("Illegal union index for 'F326': "+ unionIndex326)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex327 = (decoder.readIndex()); + if (unionIndex327 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(327, null); + } else { + if (unionIndex327 == 1) { + Utf8 charSequence327; + Object oldString327 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(327); + if (oldString327 instanceof Utf8) { + charSequence327 = (decoder).readString(((Utf8) oldString327)); + } else { + charSequence327 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(327, charSequence327); + } else { + throw new RuntimeException(("Illegal union index for 'F327': "+ unionIndex327)); + } + } + int unionIndex328 = (decoder.readIndex()); + if (unionIndex328 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(328, null); + } else { + if (unionIndex328 == 1) { + Utf8 charSequence328; + Object oldString328 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(328); + if (oldString328 instanceof Utf8) { + charSequence328 = (decoder).readString(((Utf8) oldString328)); + } else { + charSequence328 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(328, charSequence328); + } else { + throw new RuntimeException(("Illegal union index for 'F328': "+ unionIndex328)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex329 = (decoder.readIndex()); + if (unionIndex329 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(329, null); + } else { + if (unionIndex329 == 1) { + Utf8 charSequence329; + Object oldString329 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(329); + if (oldString329 instanceof Utf8) { + charSequence329 = (decoder).readString(((Utf8) oldString329)); + } else { + charSequence329 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(329, charSequence329); + } else { + throw new RuntimeException(("Illegal union index for 'F329': "+ unionIndex329)); + } + } + int unionIndex330 = (decoder.readIndex()); + if (unionIndex330 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(330, null); + } else { + if (unionIndex330 == 1) { + Utf8 charSequence330; + Object oldString330 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(330); + if (oldString330 instanceof Utf8) { + charSequence330 = (decoder).readString(((Utf8) oldString330)); + } else { + charSequence330 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(330, charSequence330); + } else { + throw new RuntimeException(("Illegal union index for 'F330': "+ unionIndex330)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex331 = (decoder.readIndex()); + if (unionIndex331 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(331, null); + } else { + if (unionIndex331 == 1) { + Utf8 charSequence331; + Object oldString331 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(331); + if (oldString331 instanceof Utf8) { + charSequence331 = (decoder).readString(((Utf8) oldString331)); + } else { + charSequence331 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(331, charSequence331); + } else { + throw new RuntimeException(("Illegal union index for 'F331': "+ unionIndex331)); + } + } + int unionIndex332 = (decoder.readIndex()); + if (unionIndex332 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(332, null); + } else { + if (unionIndex332 == 1) { + Utf8 charSequence332; + Object oldString332 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(332); + if (oldString332 instanceof Utf8) { + charSequence332 = (decoder).readString(((Utf8) oldString332)); + } else { + charSequence332 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(332, charSequence332); + } else { + throw new RuntimeException(("Illegal union index for 'F332': "+ unionIndex332)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex333 = (decoder.readIndex()); + if (unionIndex333 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(333, null); + } else { + if (unionIndex333 == 1) { + Utf8 charSequence333; + Object oldString333 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(333); + if (oldString333 instanceof Utf8) { + charSequence333 = (decoder).readString(((Utf8) oldString333)); + } else { + charSequence333 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(333, charSequence333); + } else { + throw new RuntimeException(("Illegal union index for 'F333': "+ unionIndex333)); + } + } + int unionIndex334 = (decoder.readIndex()); + if (unionIndex334 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(334, null); + } else { + if (unionIndex334 == 1) { + Utf8 charSequence334; + Object oldString334 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(334); + if (oldString334 instanceof Utf8) { + charSequence334 = (decoder).readString(((Utf8) oldString334)); + } else { + charSequence334 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(334, charSequence334); + } else { + throw new RuntimeException(("Illegal union index for 'F334': "+ unionIndex334)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex335 = (decoder.readIndex()); + if (unionIndex335 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(335, null); + } else { + if (unionIndex335 == 1) { + Utf8 charSequence335; + Object oldString335 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(335); + if (oldString335 instanceof Utf8) { + charSequence335 = (decoder).readString(((Utf8) oldString335)); + } else { + charSequence335 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(335, charSequence335); + } else { + throw new RuntimeException(("Illegal union index for 'F335': "+ unionIndex335)); + } + } + int unionIndex336 = (decoder.readIndex()); + if (unionIndex336 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(336, null); + } else { + if (unionIndex336 == 1) { + Utf8 charSequence336; + Object oldString336 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(336); + if (oldString336 instanceof Utf8) { + charSequence336 = (decoder).readString(((Utf8) oldString336)); + } else { + charSequence336 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(336, charSequence336); + } else { + throw new RuntimeException(("Illegal union index for 'F336': "+ unionIndex336)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex337 = (decoder.readIndex()); + if (unionIndex337 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(337, null); + } else { + if (unionIndex337 == 1) { + Utf8 charSequence337; + Object oldString337 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(337); + if (oldString337 instanceof Utf8) { + charSequence337 = (decoder).readString(((Utf8) oldString337)); + } else { + charSequence337 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(337, charSequence337); + } else { + throw new RuntimeException(("Illegal union index for 'F337': "+ unionIndex337)); + } + } + int unionIndex338 = (decoder.readIndex()); + if (unionIndex338 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(338, null); + } else { + if (unionIndex338 == 1) { + Utf8 charSequence338; + Object oldString338 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(338); + if (oldString338 instanceof Utf8) { + charSequence338 = (decoder).readString(((Utf8) oldString338)); + } else { + charSequence338 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(338, charSequence338); + } else { + throw new RuntimeException(("Illegal union index for 'F338': "+ unionIndex338)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex339 = (decoder.readIndex()); + if (unionIndex339 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(339, null); + } else { + if (unionIndex339 == 1) { + Utf8 charSequence339; + Object oldString339 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(339); + if (oldString339 instanceof Utf8) { + charSequence339 = (decoder).readString(((Utf8) oldString339)); + } else { + charSequence339 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(339, charSequence339); + } else { + throw new RuntimeException(("Illegal union index for 'F339': "+ unionIndex339)); + } + } + int unionIndex340 = (decoder.readIndex()); + if (unionIndex340 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(340, null); + } else { + if (unionIndex340 == 1) { + Utf8 charSequence340; + Object oldString340 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(340); + if (oldString340 instanceof Utf8) { + charSequence340 = (decoder).readString(((Utf8) oldString340)); + } else { + charSequence340 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(340, charSequence340); + } else { + throw new RuntimeException(("Illegal union index for 'F340': "+ unionIndex340)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex341 = (decoder.readIndex()); + if (unionIndex341 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(341, null); + } else { + if (unionIndex341 == 1) { + Utf8 charSequence341; + Object oldString341 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(341); + if (oldString341 instanceof Utf8) { + charSequence341 = (decoder).readString(((Utf8) oldString341)); + } else { + charSequence341 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(341, charSequence341); + } else { + throw new RuntimeException(("Illegal union index for 'F341': "+ unionIndex341)); + } + } + int unionIndex342 = (decoder.readIndex()); + if (unionIndex342 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(342, null); + } else { + if (unionIndex342 == 1) { + Utf8 charSequence342; + Object oldString342 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(342); + if (oldString342 instanceof Utf8) { + charSequence342 = (decoder).readString(((Utf8) oldString342)); + } else { + charSequence342 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(342, charSequence342); + } else { + throw new RuntimeException(("Illegal union index for 'F342': "+ unionIndex342)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex343 = (decoder.readIndex()); + if (unionIndex343 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(343, null); + } else { + if (unionIndex343 == 1) { + Utf8 charSequence343; + Object oldString343 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(343); + if (oldString343 instanceof Utf8) { + charSequence343 = (decoder).readString(((Utf8) oldString343)); + } else { + charSequence343 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(343, charSequence343); + } else { + throw new RuntimeException(("Illegal union index for 'F343': "+ unionIndex343)); + } + } + int unionIndex344 = (decoder.readIndex()); + if (unionIndex344 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(344, null); + } else { + if (unionIndex344 == 1) { + Utf8 charSequence344; + Object oldString344 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(344); + if (oldString344 instanceof Utf8) { + charSequence344 = (decoder).readString(((Utf8) oldString344)); + } else { + charSequence344 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(344, charSequence344); + } else { + throw new RuntimeException(("Illegal union index for 'F344': "+ unionIndex344)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex345 = (decoder.readIndex()); + if (unionIndex345 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(345, null); + } else { + if (unionIndex345 == 1) { + Utf8 charSequence345; + Object oldString345 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(345); + if (oldString345 instanceof Utf8) { + charSequence345 = (decoder).readString(((Utf8) oldString345)); + } else { + charSequence345 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(345, charSequence345); + } else { + throw new RuntimeException(("Illegal union index for 'F345': "+ unionIndex345)); + } + } + int unionIndex346 = (decoder.readIndex()); + if (unionIndex346 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(346, null); + } else { + if (unionIndex346 == 1) { + Utf8 charSequence346; + Object oldString346 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(346); + if (oldString346 instanceof Utf8) { + charSequence346 = (decoder).readString(((Utf8) oldString346)); + } else { + charSequence346 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(346, charSequence346); + } else { + throw new RuntimeException(("Illegal union index for 'F346': "+ unionIndex346)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex347 = (decoder.readIndex()); + if (unionIndex347 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(347, null); + } else { + if (unionIndex347 == 1) { + Utf8 charSequence347; + Object oldString347 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(347); + if (oldString347 instanceof Utf8) { + charSequence347 = (decoder).readString(((Utf8) oldString347)); + } else { + charSequence347 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(347, charSequence347); + } else { + throw new RuntimeException(("Illegal union index for 'F347': "+ unionIndex347)); + } + } + int unionIndex348 = (decoder.readIndex()); + if (unionIndex348 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(348, null); + } else { + if (unionIndex348 == 1) { + Utf8 charSequence348; + Object oldString348 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(348); + if (oldString348 instanceof Utf8) { + charSequence348 = (decoder).readString(((Utf8) oldString348)); + } else { + charSequence348 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(348, charSequence348); + } else { + throw new RuntimeException(("Illegal union index for 'F348': "+ unionIndex348)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex349 = (decoder.readIndex()); + if (unionIndex349 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(349, null); + } else { + if (unionIndex349 == 1) { + Utf8 charSequence349; + Object oldString349 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(349); + if (oldString349 instanceof Utf8) { + charSequence349 = (decoder).readString(((Utf8) oldString349)); + } else { + charSequence349 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(349, charSequence349); + } else { + throw new RuntimeException(("Illegal union index for 'F349': "+ unionIndex349)); + } + } + int unionIndex350 = (decoder.readIndex()); + if (unionIndex350 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(350, null); + } else { + if (unionIndex350 == 1) { + Utf8 charSequence350; + Object oldString350 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(350); + if (oldString350 instanceof Utf8) { + charSequence350 = (decoder).readString(((Utf8) oldString350)); + } else { + charSequence350 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(350, charSequence350); + } else { + throw new RuntimeException(("Illegal union index for 'F350': "+ unionIndex350)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex351 = (decoder.readIndex()); + if (unionIndex351 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(351, null); + } else { + if (unionIndex351 == 1) { + Utf8 charSequence351; + Object oldString351 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(351); + if (oldString351 instanceof Utf8) { + charSequence351 = (decoder).readString(((Utf8) oldString351)); + } else { + charSequence351 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(351, charSequence351); + } else { + throw new RuntimeException(("Illegal union index for 'F351': "+ unionIndex351)); + } + } + int unionIndex352 = (decoder.readIndex()); + if (unionIndex352 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(352, null); + } else { + if (unionIndex352 == 1) { + Utf8 charSequence352; + Object oldString352 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(352); + if (oldString352 instanceof Utf8) { + charSequence352 = (decoder).readString(((Utf8) oldString352)); + } else { + charSequence352 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(352, charSequence352); + } else { + throw new RuntimeException(("Illegal union index for 'F352': "+ unionIndex352)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex353 = (decoder.readIndex()); + if (unionIndex353 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(353, null); + } else { + if (unionIndex353 == 1) { + Utf8 charSequence353; + Object oldString353 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(353); + if (oldString353 instanceof Utf8) { + charSequence353 = (decoder).readString(((Utf8) oldString353)); + } else { + charSequence353 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(353, charSequence353); + } else { + throw new RuntimeException(("Illegal union index for 'F353': "+ unionIndex353)); + } + } + int unionIndex354 = (decoder.readIndex()); + if (unionIndex354 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(354, null); + } else { + if (unionIndex354 == 1) { + Utf8 charSequence354; + Object oldString354 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(354); + if (oldString354 instanceof Utf8) { + charSequence354 = (decoder).readString(((Utf8) oldString354)); + } else { + charSequence354 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(354, charSequence354); + } else { + throw new RuntimeException(("Illegal union index for 'F354': "+ unionIndex354)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex355 = (decoder.readIndex()); + if (unionIndex355 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(355, null); + } else { + if (unionIndex355 == 1) { + Utf8 charSequence355; + Object oldString355 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(355); + if (oldString355 instanceof Utf8) { + charSequence355 = (decoder).readString(((Utf8) oldString355)); + } else { + charSequence355 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(355, charSequence355); + } else { + throw new RuntimeException(("Illegal union index for 'F355': "+ unionIndex355)); + } + } + int unionIndex356 = (decoder.readIndex()); + if (unionIndex356 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(356, null); + } else { + if (unionIndex356 == 1) { + Utf8 charSequence356; + Object oldString356 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(356); + if (oldString356 instanceof Utf8) { + charSequence356 = (decoder).readString(((Utf8) oldString356)); + } else { + charSequence356 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(356, charSequence356); + } else { + throw new RuntimeException(("Illegal union index for 'F356': "+ unionIndex356)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex357 = (decoder.readIndex()); + if (unionIndex357 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(357, null); + } else { + if (unionIndex357 == 1) { + Utf8 charSequence357; + Object oldString357 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(357); + if (oldString357 instanceof Utf8) { + charSequence357 = (decoder).readString(((Utf8) oldString357)); + } else { + charSequence357 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(357, charSequence357); + } else { + throw new RuntimeException(("Illegal union index for 'F357': "+ unionIndex357)); + } + } + int unionIndex358 = (decoder.readIndex()); + if (unionIndex358 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(358, null); + } else { + if (unionIndex358 == 1) { + Utf8 charSequence358; + Object oldString358 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(358); + if (oldString358 instanceof Utf8) { + charSequence358 = (decoder).readString(((Utf8) oldString358)); + } else { + charSequence358 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(358, charSequence358); + } else { + throw new RuntimeException(("Illegal union index for 'F358': "+ unionIndex358)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex359 = (decoder.readIndex()); + if (unionIndex359 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(359, null); + } else { + if (unionIndex359 == 1) { + Utf8 charSequence359; + Object oldString359 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(359); + if (oldString359 instanceof Utf8) { + charSequence359 = (decoder).readString(((Utf8) oldString359)); + } else { + charSequence359 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(359, charSequence359); + } else { + throw new RuntimeException(("Illegal union index for 'F359': "+ unionIndex359)); + } + } + int unionIndex360 = (decoder.readIndex()); + if (unionIndex360 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(360, null); + } else { + if (unionIndex360 == 1) { + Utf8 charSequence360; + Object oldString360 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(360); + if (oldString360 instanceof Utf8) { + charSequence360 = (decoder).readString(((Utf8) oldString360)); + } else { + charSequence360 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(360, charSequence360); + } else { + throw new RuntimeException(("Illegal union index for 'F360': "+ unionIndex360)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex361 = (decoder.readIndex()); + if (unionIndex361 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(361, null); + } else { + if (unionIndex361 == 1) { + Utf8 charSequence361; + Object oldString361 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(361); + if (oldString361 instanceof Utf8) { + charSequence361 = (decoder).readString(((Utf8) oldString361)); + } else { + charSequence361 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(361, charSequence361); + } else { + throw new RuntimeException(("Illegal union index for 'F361': "+ unionIndex361)); + } + } + int unionIndex362 = (decoder.readIndex()); + if (unionIndex362 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(362, null); + } else { + if (unionIndex362 == 1) { + Utf8 charSequence362; + Object oldString362 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(362); + if (oldString362 instanceof Utf8) { + charSequence362 = (decoder).readString(((Utf8) oldString362)); + } else { + charSequence362 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(362, charSequence362); + } else { + throw new RuntimeException(("Illegal union index for 'F362': "+ unionIndex362)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex363 = (decoder.readIndex()); + if (unionIndex363 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(363, null); + } else { + if (unionIndex363 == 1) { + Utf8 charSequence363; + Object oldString363 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(363); + if (oldString363 instanceof Utf8) { + charSequence363 = (decoder).readString(((Utf8) oldString363)); + } else { + charSequence363 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(363, charSequence363); + } else { + throw new RuntimeException(("Illegal union index for 'F363': "+ unionIndex363)); + } + } + int unionIndex364 = (decoder.readIndex()); + if (unionIndex364 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(364, null); + } else { + if (unionIndex364 == 1) { + Utf8 charSequence364; + Object oldString364 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(364); + if (oldString364 instanceof Utf8) { + charSequence364 = (decoder).readString(((Utf8) oldString364)); + } else { + charSequence364 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(364, charSequence364); + } else { + throw new RuntimeException(("Illegal union index for 'F364': "+ unionIndex364)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex365 = (decoder.readIndex()); + if (unionIndex365 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(365, null); + } else { + if (unionIndex365 == 1) { + Utf8 charSequence365; + Object oldString365 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(365); + if (oldString365 instanceof Utf8) { + charSequence365 = (decoder).readString(((Utf8) oldString365)); + } else { + charSequence365 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(365, charSequence365); + } else { + throw new RuntimeException(("Illegal union index for 'F365': "+ unionIndex365)); + } + } + int unionIndex366 = (decoder.readIndex()); + if (unionIndex366 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(366, null); + } else { + if (unionIndex366 == 1) { + Utf8 charSequence366; + Object oldString366 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(366); + if (oldString366 instanceof Utf8) { + charSequence366 = (decoder).readString(((Utf8) oldString366)); + } else { + charSequence366 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(366, charSequence366); + } else { + throw new RuntimeException(("Illegal union index for 'F366': "+ unionIndex366)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex367 = (decoder.readIndex()); + if (unionIndex367 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(367, null); + } else { + if (unionIndex367 == 1) { + Utf8 charSequence367; + Object oldString367 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(367); + if (oldString367 instanceof Utf8) { + charSequence367 = (decoder).readString(((Utf8) oldString367)); + } else { + charSequence367 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(367, charSequence367); + } else { + throw new RuntimeException(("Illegal union index for 'F367': "+ unionIndex367)); + } + } + int unionIndex368 = (decoder.readIndex()); + if (unionIndex368 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(368, null); + } else { + if (unionIndex368 == 1) { + Utf8 charSequence368; + Object oldString368 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(368); + if (oldString368 instanceof Utf8) { + charSequence368 = (decoder).readString(((Utf8) oldString368)); + } else { + charSequence368 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(368, charSequence368); + } else { + throw new RuntimeException(("Illegal union index for 'F368': "+ unionIndex368)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex369 = (decoder.readIndex()); + if (unionIndex369 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(369, null); + } else { + if (unionIndex369 == 1) { + Utf8 charSequence369; + Object oldString369 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(369); + if (oldString369 instanceof Utf8) { + charSequence369 = (decoder).readString(((Utf8) oldString369)); + } else { + charSequence369 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(369, charSequence369); + } else { + throw new RuntimeException(("Illegal union index for 'F369': "+ unionIndex369)); + } + } + int unionIndex370 = (decoder.readIndex()); + if (unionIndex370 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(370, null); + } else { + if (unionIndex370 == 1) { + Utf8 charSequence370; + Object oldString370 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(370); + if (oldString370 instanceof Utf8) { + charSequence370 = (decoder).readString(((Utf8) oldString370)); + } else { + charSequence370 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(370, charSequence370); + } else { + throw new RuntimeException(("Illegal union index for 'F370': "+ unionIndex370)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex371 = (decoder.readIndex()); + if (unionIndex371 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(371, null); + } else { + if (unionIndex371 == 1) { + Utf8 charSequence371; + Object oldString371 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(371); + if (oldString371 instanceof Utf8) { + charSequence371 = (decoder).readString(((Utf8) oldString371)); + } else { + charSequence371 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(371, charSequence371); + } else { + throw new RuntimeException(("Illegal union index for 'F371': "+ unionIndex371)); + } + } + int unionIndex372 = (decoder.readIndex()); + if (unionIndex372 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(372, null); + } else { + if (unionIndex372 == 1) { + Utf8 charSequence372; + Object oldString372 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(372); + if (oldString372 instanceof Utf8) { + charSequence372 = (decoder).readString(((Utf8) oldString372)); + } else { + charSequence372 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(372, charSequence372); + } else { + throw new RuntimeException(("Illegal union index for 'F372': "+ unionIndex372)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex373 = (decoder.readIndex()); + if (unionIndex373 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(373, null); + } else { + if (unionIndex373 == 1) { + Utf8 charSequence373; + Object oldString373 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(373); + if (oldString373 instanceof Utf8) { + charSequence373 = (decoder).readString(((Utf8) oldString373)); + } else { + charSequence373 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(373, charSequence373); + } else { + throw new RuntimeException(("Illegal union index for 'F373': "+ unionIndex373)); + } + } + int unionIndex374 = (decoder.readIndex()); + if (unionIndex374 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(374, null); + } else { + if (unionIndex374 == 1) { + Utf8 charSequence374; + Object oldString374 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(374); + if (oldString374 instanceof Utf8) { + charSequence374 = (decoder).readString(((Utf8) oldString374)); + } else { + charSequence374 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(374, charSequence374); + } else { + throw new RuntimeException(("Illegal union index for 'F374': "+ unionIndex374)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex375 = (decoder.readIndex()); + if (unionIndex375 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(375, null); + } else { + if (unionIndex375 == 1) { + Utf8 charSequence375; + Object oldString375 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(375); + if (oldString375 instanceof Utf8) { + charSequence375 = (decoder).readString(((Utf8) oldString375)); + } else { + charSequence375 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(375, charSequence375); + } else { + throw new RuntimeException(("Illegal union index for 'F375': "+ unionIndex375)); + } + } + int unionIndex376 = (decoder.readIndex()); + if (unionIndex376 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(376, null); + } else { + if (unionIndex376 == 1) { + Utf8 charSequence376; + Object oldString376 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(376); + if (oldString376 instanceof Utf8) { + charSequence376 = (decoder).readString(((Utf8) oldString376)); + } else { + charSequence376 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(376, charSequence376); + } else { + throw new RuntimeException(("Illegal union index for 'F376': "+ unionIndex376)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex377 = (decoder.readIndex()); + if (unionIndex377 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(377, null); + } else { + if (unionIndex377 == 1) { + Utf8 charSequence377; + Object oldString377 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(377); + if (oldString377 instanceof Utf8) { + charSequence377 = (decoder).readString(((Utf8) oldString377)); + } else { + charSequence377 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(377, charSequence377); + } else { + throw new RuntimeException(("Illegal union index for 'F377': "+ unionIndex377)); + } + } + int unionIndex378 = (decoder.readIndex()); + if (unionIndex378 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(378, null); + } else { + if (unionIndex378 == 1) { + Utf8 charSequence378; + Object oldString378 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(378); + if (oldString378 instanceof Utf8) { + charSequence378 = (decoder).readString(((Utf8) oldString378)); + } else { + charSequence378 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(378, charSequence378); + } else { + throw new RuntimeException(("Illegal union index for 'F378': "+ unionIndex378)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex379 = (decoder.readIndex()); + if (unionIndex379 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(379, null); + } else { + if (unionIndex379 == 1) { + Utf8 charSequence379; + Object oldString379 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(379); + if (oldString379 instanceof Utf8) { + charSequence379 = (decoder).readString(((Utf8) oldString379)); + } else { + charSequence379 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(379, charSequence379); + } else { + throw new RuntimeException(("Illegal union index for 'F379': "+ unionIndex379)); + } + } + int unionIndex380 = (decoder.readIndex()); + if (unionIndex380 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(380, null); + } else { + if (unionIndex380 == 1) { + Utf8 charSequence380; + Object oldString380 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(380); + if (oldString380 instanceof Utf8) { + charSequence380 = (decoder).readString(((Utf8) oldString380)); + } else { + charSequence380 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(380, charSequence380); + } else { + throw new RuntimeException(("Illegal union index for 'F380': "+ unionIndex380)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex381 = (decoder.readIndex()); + if (unionIndex381 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(381, null); + } else { + if (unionIndex381 == 1) { + Utf8 charSequence381; + Object oldString381 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(381); + if (oldString381 instanceof Utf8) { + charSequence381 = (decoder).readString(((Utf8) oldString381)); + } else { + charSequence381 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(381, charSequence381); + } else { + throw new RuntimeException(("Illegal union index for 'F381': "+ unionIndex381)); + } + } + int unionIndex382 = (decoder.readIndex()); + if (unionIndex382 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(382, null); + } else { + if (unionIndex382 == 1) { + Utf8 charSequence382; + Object oldString382 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(382); + if (oldString382 instanceof Utf8) { + charSequence382 = (decoder).readString(((Utf8) oldString382)); + } else { + charSequence382 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(382, charSequence382); + } else { + throw new RuntimeException(("Illegal union index for 'F382': "+ unionIndex382)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex383 = (decoder.readIndex()); + if (unionIndex383 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(383, null); + } else { + if (unionIndex383 == 1) { + Utf8 charSequence383; + Object oldString383 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(383); + if (oldString383 instanceof Utf8) { + charSequence383 = (decoder).readString(((Utf8) oldString383)); + } else { + charSequence383 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(383, charSequence383); + } else { + throw new RuntimeException(("Illegal union index for 'F383': "+ unionIndex383)); + } + } + int unionIndex384 = (decoder.readIndex()); + if (unionIndex384 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(384, null); + } else { + if (unionIndex384 == 1) { + Utf8 charSequence384; + Object oldString384 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(384); + if (oldString384 instanceof Utf8) { + charSequence384 = (decoder).readString(((Utf8) oldString384)); + } else { + charSequence384 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(384, charSequence384); + } else { + throw new RuntimeException(("Illegal union index for 'F384': "+ unionIndex384)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex385 = (decoder.readIndex()); + if (unionIndex385 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(385, null); + } else { + if (unionIndex385 == 1) { + Utf8 charSequence385; + Object oldString385 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(385); + if (oldString385 instanceof Utf8) { + charSequence385 = (decoder).readString(((Utf8) oldString385)); + } else { + charSequence385 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(385, charSequence385); + } else { + throw new RuntimeException(("Illegal union index for 'F385': "+ unionIndex385)); + } + } + int unionIndex386 = (decoder.readIndex()); + if (unionIndex386 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(386, null); + } else { + if (unionIndex386 == 1) { + Utf8 charSequence386; + Object oldString386 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(386); + if (oldString386 instanceof Utf8) { + charSequence386 = (decoder).readString(((Utf8) oldString386)); + } else { + charSequence386 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(386, charSequence386); + } else { + throw new RuntimeException(("Illegal union index for 'F386': "+ unionIndex386)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex387 = (decoder.readIndex()); + if (unionIndex387 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(387, null); + } else { + if (unionIndex387 == 1) { + Utf8 charSequence387; + Object oldString387 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(387); + if (oldString387 instanceof Utf8) { + charSequence387 = (decoder).readString(((Utf8) oldString387)); + } else { + charSequence387 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(387, charSequence387); + } else { + throw new RuntimeException(("Illegal union index for 'F387': "+ unionIndex387)); + } + } + int unionIndex388 = (decoder.readIndex()); + if (unionIndex388 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(388, null); + } else { + if (unionIndex388 == 1) { + Utf8 charSequence388; + Object oldString388 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(388); + if (oldString388 instanceof Utf8) { + charSequence388 = (decoder).readString(((Utf8) oldString388)); + } else { + charSequence388 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(388, charSequence388); + } else { + throw new RuntimeException(("Illegal union index for 'F388': "+ unionIndex388)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex389 = (decoder.readIndex()); + if (unionIndex389 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(389, null); + } else { + if (unionIndex389 == 1) { + Utf8 charSequence389; + Object oldString389 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(389); + if (oldString389 instanceof Utf8) { + charSequence389 = (decoder).readString(((Utf8) oldString389)); + } else { + charSequence389 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(389, charSequence389); + } else { + throw new RuntimeException(("Illegal union index for 'F389': "+ unionIndex389)); + } + } + int unionIndex390 = (decoder.readIndex()); + if (unionIndex390 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(390, null); + } else { + if (unionIndex390 == 1) { + Utf8 charSequence390; + Object oldString390 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(390); + if (oldString390 instanceof Utf8) { + charSequence390 = (decoder).readString(((Utf8) oldString390)); + } else { + charSequence390 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(390, charSequence390); + } else { + throw new RuntimeException(("Illegal union index for 'F390': "+ unionIndex390)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex391 = (decoder.readIndex()); + if (unionIndex391 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(391, null); + } else { + if (unionIndex391 == 1) { + Utf8 charSequence391; + Object oldString391 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(391); + if (oldString391 instanceof Utf8) { + charSequence391 = (decoder).readString(((Utf8) oldString391)); + } else { + charSequence391 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(391, charSequence391); + } else { + throw new RuntimeException(("Illegal union index for 'F391': "+ unionIndex391)); + } + } + int unionIndex392 = (decoder.readIndex()); + if (unionIndex392 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(392, null); + } else { + if (unionIndex392 == 1) { + Utf8 charSequence392; + Object oldString392 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(392); + if (oldString392 instanceof Utf8) { + charSequence392 = (decoder).readString(((Utf8) oldString392)); + } else { + charSequence392 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(392, charSequence392); + } else { + throw new RuntimeException(("Illegal union index for 'F392': "+ unionIndex392)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex393 = (decoder.readIndex()); + if (unionIndex393 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(393, null); + } else { + if (unionIndex393 == 1) { + Utf8 charSequence393; + Object oldString393 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(393); + if (oldString393 instanceof Utf8) { + charSequence393 = (decoder).readString(((Utf8) oldString393)); + } else { + charSequence393 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(393, charSequence393); + } else { + throw new RuntimeException(("Illegal union index for 'F393': "+ unionIndex393)); + } + } + int unionIndex394 = (decoder.readIndex()); + if (unionIndex394 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(394, null); + } else { + if (unionIndex394 == 1) { + Utf8 charSequence394; + Object oldString394 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(394); + if (oldString394 instanceof Utf8) { + charSequence394 = (decoder).readString(((Utf8) oldString394)); + } else { + charSequence394 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(394, charSequence394); + } else { + throw new RuntimeException(("Illegal union index for 'F394': "+ unionIndex394)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex395 = (decoder.readIndex()); + if (unionIndex395 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(395, null); + } else { + if (unionIndex395 == 1) { + Utf8 charSequence395; + Object oldString395 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(395); + if (oldString395 instanceof Utf8) { + charSequence395 = (decoder).readString(((Utf8) oldString395)); + } else { + charSequence395 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(395, charSequence395); + } else { + throw new RuntimeException(("Illegal union index for 'F395': "+ unionIndex395)); + } + } + int unionIndex396 = (decoder.readIndex()); + if (unionIndex396 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(396, null); + } else { + if (unionIndex396 == 1) { + Utf8 charSequence396; + Object oldString396 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(396); + if (oldString396 instanceof Utf8) { + charSequence396 = (decoder).readString(((Utf8) oldString396)); + } else { + charSequence396 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(396, charSequence396); + } else { + throw new RuntimeException(("Illegal union index for 'F396': "+ unionIndex396)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex397 = (decoder.readIndex()); + if (unionIndex397 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(397, null); + } else { + if (unionIndex397 == 1) { + Utf8 charSequence397; + Object oldString397 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(397); + if (oldString397 instanceof Utf8) { + charSequence397 = (decoder).readString(((Utf8) oldString397)); + } else { + charSequence397 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(397, charSequence397); + } else { + throw new RuntimeException(("Illegal union index for 'F397': "+ unionIndex397)); + } + } + int unionIndex398 = (decoder.readIndex()); + if (unionIndex398 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(398, null); + } else { + if (unionIndex398 == 1) { + Utf8 charSequence398; + Object oldString398 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(398); + if (oldString398 instanceof Utf8) { + charSequence398 = (decoder).readString(((Utf8) oldString398)); + } else { + charSequence398 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(398, charSequence398); + } else { + throw new RuntimeException(("Illegal union index for 'F398': "+ unionIndex398)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex399 = (decoder.readIndex()); + if (unionIndex399 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(399, null); + } else { + if (unionIndex399 == 1) { + Utf8 charSequence399; + Object oldString399 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(399); + if (oldString399 instanceof Utf8) { + charSequence399 = (decoder).readString(((Utf8) oldString399)); + } else { + charSequence399 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(399, charSequence399); + } else { + throw new RuntimeException(("Illegal union index for 'F399': "+ unionIndex399)); + } + } + int unionIndex400 = (decoder.readIndex()); + if (unionIndex400 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(400, null); + } else { + if (unionIndex400 == 1) { + Utf8 charSequence400; + Object oldString400 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(400); + if (oldString400 instanceof Utf8) { + charSequence400 = (decoder).readString(((Utf8) oldString400)); + } else { + charSequence400 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(400, charSequence400); + } else { + throw new RuntimeException(("Illegal union index for 'F400': "+ unionIndex400)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex401 = (decoder.readIndex()); + if (unionIndex401 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(401, null); + } else { + if (unionIndex401 == 1) { + Utf8 charSequence401; + Object oldString401 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(401); + if (oldString401 instanceof Utf8) { + charSequence401 = (decoder).readString(((Utf8) oldString401)); + } else { + charSequence401 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(401, charSequence401); + } else { + throw new RuntimeException(("Illegal union index for 'F401': "+ unionIndex401)); + } + } + int unionIndex402 = (decoder.readIndex()); + if (unionIndex402 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(402, null); + } else { + if (unionIndex402 == 1) { + Utf8 charSequence402; + Object oldString402 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(402); + if (oldString402 instanceof Utf8) { + charSequence402 = (decoder).readString(((Utf8) oldString402)); + } else { + charSequence402 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(402, charSequence402); + } else { + throw new RuntimeException(("Illegal union index for 'F402': "+ unionIndex402)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex403 = (decoder.readIndex()); + if (unionIndex403 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(403, null); + } else { + if (unionIndex403 == 1) { + Utf8 charSequence403; + Object oldString403 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(403); + if (oldString403 instanceof Utf8) { + charSequence403 = (decoder).readString(((Utf8) oldString403)); + } else { + charSequence403 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(403, charSequence403); + } else { + throw new RuntimeException(("Illegal union index for 'F403': "+ unionIndex403)); + } + } + int unionIndex404 = (decoder.readIndex()); + if (unionIndex404 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(404, null); + } else { + if (unionIndex404 == 1) { + Utf8 charSequence404; + Object oldString404 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(404); + if (oldString404 instanceof Utf8) { + charSequence404 = (decoder).readString(((Utf8) oldString404)); + } else { + charSequence404 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(404, charSequence404); + } else { + throw new RuntimeException(("Illegal union index for 'F404': "+ unionIndex404)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex405 = (decoder.readIndex()); + if (unionIndex405 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(405, null); + } else { + if (unionIndex405 == 1) { + Utf8 charSequence405; + Object oldString405 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(405); + if (oldString405 instanceof Utf8) { + charSequence405 = (decoder).readString(((Utf8) oldString405)); + } else { + charSequence405 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(405, charSequence405); + } else { + throw new RuntimeException(("Illegal union index for 'F405': "+ unionIndex405)); + } + } + int unionIndex406 = (decoder.readIndex()); + if (unionIndex406 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(406, null); + } else { + if (unionIndex406 == 1) { + Utf8 charSequence406; + Object oldString406 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(406); + if (oldString406 instanceof Utf8) { + charSequence406 = (decoder).readString(((Utf8) oldString406)); + } else { + charSequence406 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(406, charSequence406); + } else { + throw new RuntimeException(("Illegal union index for 'F406': "+ unionIndex406)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex407 = (decoder.readIndex()); + if (unionIndex407 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(407, null); + } else { + if (unionIndex407 == 1) { + Utf8 charSequence407; + Object oldString407 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(407); + if (oldString407 instanceof Utf8) { + charSequence407 = (decoder).readString(((Utf8) oldString407)); + } else { + charSequence407 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(407, charSequence407); + } else { + throw new RuntimeException(("Illegal union index for 'F407': "+ unionIndex407)); + } + } + int unionIndex408 = (decoder.readIndex()); + if (unionIndex408 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(408, null); + } else { + if (unionIndex408 == 1) { + Utf8 charSequence408; + Object oldString408 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(408); + if (oldString408 instanceof Utf8) { + charSequence408 = (decoder).readString(((Utf8) oldString408)); + } else { + charSequence408 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(408, charSequence408); + } else { + throw new RuntimeException(("Illegal union index for 'F408': "+ unionIndex408)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex409 = (decoder.readIndex()); + if (unionIndex409 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(409, null); + } else { + if (unionIndex409 == 1) { + Utf8 charSequence409; + Object oldString409 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(409); + if (oldString409 instanceof Utf8) { + charSequence409 = (decoder).readString(((Utf8) oldString409)); + } else { + charSequence409 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(409, charSequence409); + } else { + throw new RuntimeException(("Illegal union index for 'F409': "+ unionIndex409)); + } + } + int unionIndex410 = (decoder.readIndex()); + if (unionIndex410 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(410, null); + } else { + if (unionIndex410 == 1) { + Utf8 charSequence410; + Object oldString410 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(410); + if (oldString410 instanceof Utf8) { + charSequence410 = (decoder).readString(((Utf8) oldString410)); + } else { + charSequence410 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(410, charSequence410); + } else { + throw new RuntimeException(("Illegal union index for 'F410': "+ unionIndex410)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex411 = (decoder.readIndex()); + if (unionIndex411 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(411, null); + } else { + if (unionIndex411 == 1) { + Utf8 charSequence411; + Object oldString411 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(411); + if (oldString411 instanceof Utf8) { + charSequence411 = (decoder).readString(((Utf8) oldString411)); + } else { + charSequence411 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(411, charSequence411); + } else { + throw new RuntimeException(("Illegal union index for 'F411': "+ unionIndex411)); + } + } + int unionIndex412 = (decoder.readIndex()); + if (unionIndex412 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(412, null); + } else { + if (unionIndex412 == 1) { + Utf8 charSequence412; + Object oldString412 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(412); + if (oldString412 instanceof Utf8) { + charSequence412 = (decoder).readString(((Utf8) oldString412)); + } else { + charSequence412 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(412, charSequence412); + } else { + throw new RuntimeException(("Illegal union index for 'F412': "+ unionIndex412)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex413 = (decoder.readIndex()); + if (unionIndex413 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(413, null); + } else { + if (unionIndex413 == 1) { + Utf8 charSequence413; + Object oldString413 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(413); + if (oldString413 instanceof Utf8) { + charSequence413 = (decoder).readString(((Utf8) oldString413)); + } else { + charSequence413 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(413, charSequence413); + } else { + throw new RuntimeException(("Illegal union index for 'F413': "+ unionIndex413)); + } + } + int unionIndex414 = (decoder.readIndex()); + if (unionIndex414 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(414, null); + } else { + if (unionIndex414 == 1) { + Utf8 charSequence414; + Object oldString414 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(414); + if (oldString414 instanceof Utf8) { + charSequence414 = (decoder).readString(((Utf8) oldString414)); + } else { + charSequence414 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(414, charSequence414); + } else { + throw new RuntimeException(("Illegal union index for 'F414': "+ unionIndex414)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex415 = (decoder.readIndex()); + if (unionIndex415 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(415, null); + } else { + if (unionIndex415 == 1) { + Utf8 charSequence415; + Object oldString415 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(415); + if (oldString415 instanceof Utf8) { + charSequence415 = (decoder).readString(((Utf8) oldString415)); + } else { + charSequence415 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(415, charSequence415); + } else { + throw new RuntimeException(("Illegal union index for 'F415': "+ unionIndex415)); + } + } + int unionIndex416 = (decoder.readIndex()); + if (unionIndex416 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(416, null); + } else { + if (unionIndex416 == 1) { + Utf8 charSequence416; + Object oldString416 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(416); + if (oldString416 instanceof Utf8) { + charSequence416 = (decoder).readString(((Utf8) oldString416)); + } else { + charSequence416 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(416, charSequence416); + } else { + throw new RuntimeException(("Illegal union index for 'F416': "+ unionIndex416)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex417 = (decoder.readIndex()); + if (unionIndex417 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(417, null); + } else { + if (unionIndex417 == 1) { + Utf8 charSequence417; + Object oldString417 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(417); + if (oldString417 instanceof Utf8) { + charSequence417 = (decoder).readString(((Utf8) oldString417)); + } else { + charSequence417 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(417, charSequence417); + } else { + throw new RuntimeException(("Illegal union index for 'F417': "+ unionIndex417)); + } + } + int unionIndex418 = (decoder.readIndex()); + if (unionIndex418 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(418, null); + } else { + if (unionIndex418 == 1) { + Utf8 charSequence418; + Object oldString418 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(418); + if (oldString418 instanceof Utf8) { + charSequence418 = (decoder).readString(((Utf8) oldString418)); + } else { + charSequence418 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(418, charSequence418); + } else { + throw new RuntimeException(("Illegal union index for 'F418': "+ unionIndex418)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex419 = (decoder.readIndex()); + if (unionIndex419 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(419, null); + } else { + if (unionIndex419 == 1) { + Utf8 charSequence419; + Object oldString419 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(419); + if (oldString419 instanceof Utf8) { + charSequence419 = (decoder).readString(((Utf8) oldString419)); + } else { + charSequence419 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(419, charSequence419); + } else { + throw new RuntimeException(("Illegal union index for 'F419': "+ unionIndex419)); + } + } + int unionIndex420 = (decoder.readIndex()); + if (unionIndex420 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(420, null); + } else { + if (unionIndex420 == 1) { + Utf8 charSequence420; + Object oldString420 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(420); + if (oldString420 instanceof Utf8) { + charSequence420 = (decoder).readString(((Utf8) oldString420)); + } else { + charSequence420 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(420, charSequence420); + } else { + throw new RuntimeException(("Illegal union index for 'F420': "+ unionIndex420)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex421 = (decoder.readIndex()); + if (unionIndex421 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(421, null); + } else { + if (unionIndex421 == 1) { + Utf8 charSequence421; + Object oldString421 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(421); + if (oldString421 instanceof Utf8) { + charSequence421 = (decoder).readString(((Utf8) oldString421)); + } else { + charSequence421 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(421, charSequence421); + } else { + throw new RuntimeException(("Illegal union index for 'F421': "+ unionIndex421)); + } + } + int unionIndex422 = (decoder.readIndex()); + if (unionIndex422 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(422, null); + } else { + if (unionIndex422 == 1) { + Utf8 charSequence422; + Object oldString422 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(422); + if (oldString422 instanceof Utf8) { + charSequence422 = (decoder).readString(((Utf8) oldString422)); + } else { + charSequence422 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(422, charSequence422); + } else { + throw new RuntimeException(("Illegal union index for 'F422': "+ unionIndex422)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex423 = (decoder.readIndex()); + if (unionIndex423 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(423, null); + } else { + if (unionIndex423 == 1) { + Utf8 charSequence423; + Object oldString423 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(423); + if (oldString423 instanceof Utf8) { + charSequence423 = (decoder).readString(((Utf8) oldString423)); + } else { + charSequence423 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(423, charSequence423); + } else { + throw new RuntimeException(("Illegal union index for 'F423': "+ unionIndex423)); + } + } + int unionIndex424 = (decoder.readIndex()); + if (unionIndex424 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(424, null); + } else { + if (unionIndex424 == 1) { + Utf8 charSequence424; + Object oldString424 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(424); + if (oldString424 instanceof Utf8) { + charSequence424 = (decoder).readString(((Utf8) oldString424)); + } else { + charSequence424 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(424, charSequence424); + } else { + throw new RuntimeException(("Illegal union index for 'F424': "+ unionIndex424)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex425 = (decoder.readIndex()); + if (unionIndex425 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(425, null); + } else { + if (unionIndex425 == 1) { + Utf8 charSequence425; + Object oldString425 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(425); + if (oldString425 instanceof Utf8) { + charSequence425 = (decoder).readString(((Utf8) oldString425)); + } else { + charSequence425 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(425, charSequence425); + } else { + throw new RuntimeException(("Illegal union index for 'F425': "+ unionIndex425)); + } + } + int unionIndex426 = (decoder.readIndex()); + if (unionIndex426 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(426, null); + } else { + if (unionIndex426 == 1) { + Utf8 charSequence426; + Object oldString426 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(426); + if (oldString426 instanceof Utf8) { + charSequence426 = (decoder).readString(((Utf8) oldString426)); + } else { + charSequence426 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(426, charSequence426); + } else { + throw new RuntimeException(("Illegal union index for 'F426': "+ unionIndex426)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex427 = (decoder.readIndex()); + if (unionIndex427 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(427, null); + } else { + if (unionIndex427 == 1) { + Utf8 charSequence427; + Object oldString427 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(427); + if (oldString427 instanceof Utf8) { + charSequence427 = (decoder).readString(((Utf8) oldString427)); + } else { + charSequence427 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(427, charSequence427); + } else { + throw new RuntimeException(("Illegal union index for 'F427': "+ unionIndex427)); + } + } + int unionIndex428 = (decoder.readIndex()); + if (unionIndex428 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(428, null); + } else { + if (unionIndex428 == 1) { + Utf8 charSequence428; + Object oldString428 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(428); + if (oldString428 instanceof Utf8) { + charSequence428 = (decoder).readString(((Utf8) oldString428)); + } else { + charSequence428 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(428, charSequence428); + } else { + throw new RuntimeException(("Illegal union index for 'F428': "+ unionIndex428)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex429 = (decoder.readIndex()); + if (unionIndex429 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(429, null); + } else { + if (unionIndex429 == 1) { + Utf8 charSequence429; + Object oldString429 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(429); + if (oldString429 instanceof Utf8) { + charSequence429 = (decoder).readString(((Utf8) oldString429)); + } else { + charSequence429 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(429, charSequence429); + } else { + throw new RuntimeException(("Illegal union index for 'F429': "+ unionIndex429)); + } + } + int unionIndex430 = (decoder.readIndex()); + if (unionIndex430 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(430, null); + } else { + if (unionIndex430 == 1) { + Utf8 charSequence430; + Object oldString430 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(430); + if (oldString430 instanceof Utf8) { + charSequence430 = (decoder).readString(((Utf8) oldString430)); + } else { + charSequence430 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(430, charSequence430); + } else { + throw new RuntimeException(("Illegal union index for 'F430': "+ unionIndex430)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex431 = (decoder.readIndex()); + if (unionIndex431 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(431, null); + } else { + if (unionIndex431 == 1) { + Utf8 charSequence431; + Object oldString431 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(431); + if (oldString431 instanceof Utf8) { + charSequence431 = (decoder).readString(((Utf8) oldString431)); + } else { + charSequence431 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(431, charSequence431); + } else { + throw new RuntimeException(("Illegal union index for 'F431': "+ unionIndex431)); + } + } + int unionIndex432 = (decoder.readIndex()); + if (unionIndex432 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(432, null); + } else { + if (unionIndex432 == 1) { + Utf8 charSequence432; + Object oldString432 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(432); + if (oldString432 instanceof Utf8) { + charSequence432 = (decoder).readString(((Utf8) oldString432)); + } else { + charSequence432 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(432, charSequence432); + } else { + throw new RuntimeException(("Illegal union index for 'F432': "+ unionIndex432)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex433 = (decoder.readIndex()); + if (unionIndex433 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(433, null); + } else { + if (unionIndex433 == 1) { + Utf8 charSequence433; + Object oldString433 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(433); + if (oldString433 instanceof Utf8) { + charSequence433 = (decoder).readString(((Utf8) oldString433)); + } else { + charSequence433 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(433, charSequence433); + } else { + throw new RuntimeException(("Illegal union index for 'F433': "+ unionIndex433)); + } + } + int unionIndex434 = (decoder.readIndex()); + if (unionIndex434 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(434, null); + } else { + if (unionIndex434 == 1) { + Utf8 charSequence434; + Object oldString434 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(434); + if (oldString434 instanceof Utf8) { + charSequence434 = (decoder).readString(((Utf8) oldString434)); + } else { + charSequence434 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(434, charSequence434); + } else { + throw new RuntimeException(("Illegal union index for 'F434': "+ unionIndex434)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex435 = (decoder.readIndex()); + if (unionIndex435 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(435, null); + } else { + if (unionIndex435 == 1) { + Utf8 charSequence435; + Object oldString435 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(435); + if (oldString435 instanceof Utf8) { + charSequence435 = (decoder).readString(((Utf8) oldString435)); + } else { + charSequence435 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(435, charSequence435); + } else { + throw new RuntimeException(("Illegal union index for 'F435': "+ unionIndex435)); + } + } + int unionIndex436 = (decoder.readIndex()); + if (unionIndex436 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(436, null); + } else { + if (unionIndex436 == 1) { + Utf8 charSequence436; + Object oldString436 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(436); + if (oldString436 instanceof Utf8) { + charSequence436 = (decoder).readString(((Utf8) oldString436)); + } else { + charSequence436 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(436, charSequence436); + } else { + throw new RuntimeException(("Illegal union index for 'F436': "+ unionIndex436)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex437 = (decoder.readIndex()); + if (unionIndex437 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(437, null); + } else { + if (unionIndex437 == 1) { + Utf8 charSequence437; + Object oldString437 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(437); + if (oldString437 instanceof Utf8) { + charSequence437 = (decoder).readString(((Utf8) oldString437)); + } else { + charSequence437 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(437, charSequence437); + } else { + throw new RuntimeException(("Illegal union index for 'F437': "+ unionIndex437)); + } + } + int unionIndex438 = (decoder.readIndex()); + if (unionIndex438 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(438, null); + } else { + if (unionIndex438 == 1) { + Utf8 charSequence438; + Object oldString438 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(438); + if (oldString438 instanceof Utf8) { + charSequence438 = (decoder).readString(((Utf8) oldString438)); + } else { + charSequence438 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(438, charSequence438); + } else { + throw new RuntimeException(("Illegal union index for 'F438': "+ unionIndex438)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex439 = (decoder.readIndex()); + if (unionIndex439 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(439, null); + } else { + if (unionIndex439 == 1) { + Utf8 charSequence439; + Object oldString439 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(439); + if (oldString439 instanceof Utf8) { + charSequence439 = (decoder).readString(((Utf8) oldString439)); + } else { + charSequence439 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(439, charSequence439); + } else { + throw new RuntimeException(("Illegal union index for 'F439': "+ unionIndex439)); + } + } + int unionIndex440 = (decoder.readIndex()); + if (unionIndex440 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(440, null); + } else { + if (unionIndex440 == 1) { + Utf8 charSequence440; + Object oldString440 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(440); + if (oldString440 instanceof Utf8) { + charSequence440 = (decoder).readString(((Utf8) oldString440)); + } else { + charSequence440 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(440, charSequence440); + } else { + throw new RuntimeException(("Illegal union index for 'F440': "+ unionIndex440)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex441 = (decoder.readIndex()); + if (unionIndex441 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(441, null); + } else { + if (unionIndex441 == 1) { + Utf8 charSequence441; + Object oldString441 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(441); + if (oldString441 instanceof Utf8) { + charSequence441 = (decoder).readString(((Utf8) oldString441)); + } else { + charSequence441 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(441, charSequence441); + } else { + throw new RuntimeException(("Illegal union index for 'F441': "+ unionIndex441)); + } + } + int unionIndex442 = (decoder.readIndex()); + if (unionIndex442 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(442, null); + } else { + if (unionIndex442 == 1) { + Utf8 charSequence442; + Object oldString442 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(442); + if (oldString442 instanceof Utf8) { + charSequence442 = (decoder).readString(((Utf8) oldString442)); + } else { + charSequence442 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(442, charSequence442); + } else { + throw new RuntimeException(("Illegal union index for 'F442': "+ unionIndex442)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex443 = (decoder.readIndex()); + if (unionIndex443 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(443, null); + } else { + if (unionIndex443 == 1) { + Utf8 charSequence443; + Object oldString443 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(443); + if (oldString443 instanceof Utf8) { + charSequence443 = (decoder).readString(((Utf8) oldString443)); + } else { + charSequence443 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(443, charSequence443); + } else { + throw new RuntimeException(("Illegal union index for 'F443': "+ unionIndex443)); + } + } + int unionIndex444 = (decoder.readIndex()); + if (unionIndex444 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(444, null); + } else { + if (unionIndex444 == 1) { + Utf8 charSequence444; + Object oldString444 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(444); + if (oldString444 instanceof Utf8) { + charSequence444 = (decoder).readString(((Utf8) oldString444)); + } else { + charSequence444 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(444, charSequence444); + } else { + throw new RuntimeException(("Illegal union index for 'F444': "+ unionIndex444)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex445 = (decoder.readIndex()); + if (unionIndex445 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(445, null); + } else { + if (unionIndex445 == 1) { + Utf8 charSequence445; + Object oldString445 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(445); + if (oldString445 instanceof Utf8) { + charSequence445 = (decoder).readString(((Utf8) oldString445)); + } else { + charSequence445 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(445, charSequence445); + } else { + throw new RuntimeException(("Illegal union index for 'F445': "+ unionIndex445)); + } + } + int unionIndex446 = (decoder.readIndex()); + if (unionIndex446 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(446, null); + } else { + if (unionIndex446 == 1) { + Utf8 charSequence446; + Object oldString446 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(446); + if (oldString446 instanceof Utf8) { + charSequence446 = (decoder).readString(((Utf8) oldString446)); + } else { + charSequence446 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(446, charSequence446); + } else { + throw new RuntimeException(("Illegal union index for 'F446': "+ unionIndex446)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex447 = (decoder.readIndex()); + if (unionIndex447 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(447, null); + } else { + if (unionIndex447 == 1) { + Utf8 charSequence447; + Object oldString447 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(447); + if (oldString447 instanceof Utf8) { + charSequence447 = (decoder).readString(((Utf8) oldString447)); + } else { + charSequence447 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(447, charSequence447); + } else { + throw new RuntimeException(("Illegal union index for 'F447': "+ unionIndex447)); + } + } + int unionIndex448 = (decoder.readIndex()); + if (unionIndex448 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(448, null); + } else { + if (unionIndex448 == 1) { + Utf8 charSequence448; + Object oldString448 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(448); + if (oldString448 instanceof Utf8) { + charSequence448 = (decoder).readString(((Utf8) oldString448)); + } else { + charSequence448 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(448, charSequence448); + } else { + throw new RuntimeException(("Illegal union index for 'F448': "+ unionIndex448)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex449 = (decoder.readIndex()); + if (unionIndex449 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(449, null); + } else { + if (unionIndex449 == 1) { + Utf8 charSequence449; + Object oldString449 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(449); + if (oldString449 instanceof Utf8) { + charSequence449 = (decoder).readString(((Utf8) oldString449)); + } else { + charSequence449 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(449, charSequence449); + } else { + throw new RuntimeException(("Illegal union index for 'F449': "+ unionIndex449)); + } + } + int unionIndex450 = (decoder.readIndex()); + if (unionIndex450 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(450, null); + } else { + if (unionIndex450 == 1) { + Utf8 charSequence450; + Object oldString450 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(450); + if (oldString450 instanceof Utf8) { + charSequence450 = (decoder).readString(((Utf8) oldString450)); + } else { + charSequence450 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(450, charSequence450); + } else { + throw new RuntimeException(("Illegal union index for 'F450': "+ unionIndex450)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex451 = (decoder.readIndex()); + if (unionIndex451 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(451, null); + } else { + if (unionIndex451 == 1) { + Utf8 charSequence451; + Object oldString451 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(451); + if (oldString451 instanceof Utf8) { + charSequence451 = (decoder).readString(((Utf8) oldString451)); + } else { + charSequence451 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(451, charSequence451); + } else { + throw new RuntimeException(("Illegal union index for 'F451': "+ unionIndex451)); + } + } + int unionIndex452 = (decoder.readIndex()); + if (unionIndex452 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(452, null); + } else { + if (unionIndex452 == 1) { + Utf8 charSequence452; + Object oldString452 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(452); + if (oldString452 instanceof Utf8) { + charSequence452 = (decoder).readString(((Utf8) oldString452)); + } else { + charSequence452 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(452, charSequence452); + } else { + throw new RuntimeException(("Illegal union index for 'F452': "+ unionIndex452)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex453 = (decoder.readIndex()); + if (unionIndex453 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(453, null); + } else { + if (unionIndex453 == 1) { + Utf8 charSequence453; + Object oldString453 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(453); + if (oldString453 instanceof Utf8) { + charSequence453 = (decoder).readString(((Utf8) oldString453)); + } else { + charSequence453 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(453, charSequence453); + } else { + throw new RuntimeException(("Illegal union index for 'F453': "+ unionIndex453)); + } + } + int unionIndex454 = (decoder.readIndex()); + if (unionIndex454 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(454, null); + } else { + if (unionIndex454 == 1) { + Utf8 charSequence454; + Object oldString454 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(454); + if (oldString454 instanceof Utf8) { + charSequence454 = (decoder).readString(((Utf8) oldString454)); + } else { + charSequence454 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(454, charSequence454); + } else { + throw new RuntimeException(("Illegal union index for 'F454': "+ unionIndex454)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex455 = (decoder.readIndex()); + if (unionIndex455 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(455, null); + } else { + if (unionIndex455 == 1) { + Utf8 charSequence455; + Object oldString455 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(455); + if (oldString455 instanceof Utf8) { + charSequence455 = (decoder).readString(((Utf8) oldString455)); + } else { + charSequence455 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(455, charSequence455); + } else { + throw new RuntimeException(("Illegal union index for 'F455': "+ unionIndex455)); + } + } + int unionIndex456 = (decoder.readIndex()); + if (unionIndex456 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(456, null); + } else { + if (unionIndex456 == 1) { + Utf8 charSequence456; + Object oldString456 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(456); + if (oldString456 instanceof Utf8) { + charSequence456 = (decoder).readString(((Utf8) oldString456)); + } else { + charSequence456 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(456, charSequence456); + } else { + throw new RuntimeException(("Illegal union index for 'F456': "+ unionIndex456)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex457 = (decoder.readIndex()); + if (unionIndex457 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(457, null); + } else { + if (unionIndex457 == 1) { + Utf8 charSequence457; + Object oldString457 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(457); + if (oldString457 instanceof Utf8) { + charSequence457 = (decoder).readString(((Utf8) oldString457)); + } else { + charSequence457 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(457, charSequence457); + } else { + throw new RuntimeException(("Illegal union index for 'F457': "+ unionIndex457)); + } + } + int unionIndex458 = (decoder.readIndex()); + if (unionIndex458 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(458, null); + } else { + if (unionIndex458 == 1) { + Utf8 charSequence458; + Object oldString458 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(458); + if (oldString458 instanceof Utf8) { + charSequence458 = (decoder).readString(((Utf8) oldString458)); + } else { + charSequence458 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(458, charSequence458); + } else { + throw new RuntimeException(("Illegal union index for 'F458': "+ unionIndex458)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex459 = (decoder.readIndex()); + if (unionIndex459 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(459, null); + } else { + if (unionIndex459 == 1) { + Utf8 charSequence459; + Object oldString459 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(459); + if (oldString459 instanceof Utf8) { + charSequence459 = (decoder).readString(((Utf8) oldString459)); + } else { + charSequence459 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(459, charSequence459); + } else { + throw new RuntimeException(("Illegal union index for 'F459': "+ unionIndex459)); + } + } + int unionIndex460 = (decoder.readIndex()); + if (unionIndex460 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(460, null); + } else { + if (unionIndex460 == 1) { + Utf8 charSequence460; + Object oldString460 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(460); + if (oldString460 instanceof Utf8) { + charSequence460 = (decoder).readString(((Utf8) oldString460)); + } else { + charSequence460 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(460, charSequence460); + } else { + throw new RuntimeException(("Illegal union index for 'F460': "+ unionIndex460)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex461 = (decoder.readIndex()); + if (unionIndex461 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(461, null); + } else { + if (unionIndex461 == 1) { + Utf8 charSequence461; + Object oldString461 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(461); + if (oldString461 instanceof Utf8) { + charSequence461 = (decoder).readString(((Utf8) oldString461)); + } else { + charSequence461 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(461, charSequence461); + } else { + throw new RuntimeException(("Illegal union index for 'F461': "+ unionIndex461)); + } + } + int unionIndex462 = (decoder.readIndex()); + if (unionIndex462 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(462, null); + } else { + if (unionIndex462 == 1) { + Utf8 charSequence462; + Object oldString462 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(462); + if (oldString462 instanceof Utf8) { + charSequence462 = (decoder).readString(((Utf8) oldString462)); + } else { + charSequence462 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(462, charSequence462); + } else { + throw new RuntimeException(("Illegal union index for 'F462': "+ unionIndex462)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex463 = (decoder.readIndex()); + if (unionIndex463 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(463, null); + } else { + if (unionIndex463 == 1) { + Utf8 charSequence463; + Object oldString463 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(463); + if (oldString463 instanceof Utf8) { + charSequence463 = (decoder).readString(((Utf8) oldString463)); + } else { + charSequence463 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(463, charSequence463); + } else { + throw new RuntimeException(("Illegal union index for 'F463': "+ unionIndex463)); + } + } + int unionIndex464 = (decoder.readIndex()); + if (unionIndex464 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(464, null); + } else { + if (unionIndex464 == 1) { + Utf8 charSequence464; + Object oldString464 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(464); + if (oldString464 instanceof Utf8) { + charSequence464 = (decoder).readString(((Utf8) oldString464)); + } else { + charSequence464 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(464, charSequence464); + } else { + throw new RuntimeException(("Illegal union index for 'F464': "+ unionIndex464)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex465 = (decoder.readIndex()); + if (unionIndex465 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(465, null); + } else { + if (unionIndex465 == 1) { + Utf8 charSequence465; + Object oldString465 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(465); + if (oldString465 instanceof Utf8) { + charSequence465 = (decoder).readString(((Utf8) oldString465)); + } else { + charSequence465 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(465, charSequence465); + } else { + throw new RuntimeException(("Illegal union index for 'F465': "+ unionIndex465)); + } + } + int unionIndex466 = (decoder.readIndex()); + if (unionIndex466 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(466, null); + } else { + if (unionIndex466 == 1) { + Utf8 charSequence466; + Object oldString466 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(466); + if (oldString466 instanceof Utf8) { + charSequence466 = (decoder).readString(((Utf8) oldString466)); + } else { + charSequence466 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(466, charSequence466); + } else { + throw new RuntimeException(("Illegal union index for 'F466': "+ unionIndex466)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex467 = (decoder.readIndex()); + if (unionIndex467 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(467, null); + } else { + if (unionIndex467 == 1) { + Utf8 charSequence467; + Object oldString467 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(467); + if (oldString467 instanceof Utf8) { + charSequence467 = (decoder).readString(((Utf8) oldString467)); + } else { + charSequence467 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(467, charSequence467); + } else { + throw new RuntimeException(("Illegal union index for 'F467': "+ unionIndex467)); + } + } + int unionIndex468 = (decoder.readIndex()); + if (unionIndex468 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(468, null); + } else { + if (unionIndex468 == 1) { + Utf8 charSequence468; + Object oldString468 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(468); + if (oldString468 instanceof Utf8) { + charSequence468 = (decoder).readString(((Utf8) oldString468)); + } else { + charSequence468 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(468, charSequence468); + } else { + throw new RuntimeException(("Illegal union index for 'F468': "+ unionIndex468)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex469 = (decoder.readIndex()); + if (unionIndex469 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(469, null); + } else { + if (unionIndex469 == 1) { + Utf8 charSequence469; + Object oldString469 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(469); + if (oldString469 instanceof Utf8) { + charSequence469 = (decoder).readString(((Utf8) oldString469)); + } else { + charSequence469 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(469, charSequence469); + } else { + throw new RuntimeException(("Illegal union index for 'F469': "+ unionIndex469)); + } + } + int unionIndex470 = (decoder.readIndex()); + if (unionIndex470 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(470, null); + } else { + if (unionIndex470 == 1) { + Utf8 charSequence470; + Object oldString470 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(470); + if (oldString470 instanceof Utf8) { + charSequence470 = (decoder).readString(((Utf8) oldString470)); + } else { + charSequence470 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(470, charSequence470); + } else { + throw new RuntimeException(("Illegal union index for 'F470': "+ unionIndex470)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex471 = (decoder.readIndex()); + if (unionIndex471 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(471, null); + } else { + if (unionIndex471 == 1) { + Utf8 charSequence471; + Object oldString471 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(471); + if (oldString471 instanceof Utf8) { + charSequence471 = (decoder).readString(((Utf8) oldString471)); + } else { + charSequence471 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(471, charSequence471); + } else { + throw new RuntimeException(("Illegal union index for 'F471': "+ unionIndex471)); + } + } + int unionIndex472 = (decoder.readIndex()); + if (unionIndex472 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(472, null); + } else { + if (unionIndex472 == 1) { + Utf8 charSequence472; + Object oldString472 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(472); + if (oldString472 instanceof Utf8) { + charSequence472 = (decoder).readString(((Utf8) oldString472)); + } else { + charSequence472 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(472, charSequence472); + } else { + throw new RuntimeException(("Illegal union index for 'F472': "+ unionIndex472)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex473 = (decoder.readIndex()); + if (unionIndex473 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(473, null); + } else { + if (unionIndex473 == 1) { + Utf8 charSequence473; + Object oldString473 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(473); + if (oldString473 instanceof Utf8) { + charSequence473 = (decoder).readString(((Utf8) oldString473)); + } else { + charSequence473 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(473, charSequence473); + } else { + throw new RuntimeException(("Illegal union index for 'F473': "+ unionIndex473)); + } + } + int unionIndex474 = (decoder.readIndex()); + if (unionIndex474 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(474, null); + } else { + if (unionIndex474 == 1) { + Utf8 charSequence474; + Object oldString474 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(474); + if (oldString474 instanceof Utf8) { + charSequence474 = (decoder).readString(((Utf8) oldString474)); + } else { + charSequence474 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(474, charSequence474); + } else { + throw new RuntimeException(("Illegal union index for 'F474': "+ unionIndex474)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex475 = (decoder.readIndex()); + if (unionIndex475 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(475, null); + } else { + if (unionIndex475 == 1) { + Utf8 charSequence475; + Object oldString475 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(475); + if (oldString475 instanceof Utf8) { + charSequence475 = (decoder).readString(((Utf8) oldString475)); + } else { + charSequence475 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(475, charSequence475); + } else { + throw new RuntimeException(("Illegal union index for 'F475': "+ unionIndex475)); + } + } + int unionIndex476 = (decoder.readIndex()); + if (unionIndex476 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(476, null); + } else { + if (unionIndex476 == 1) { + Utf8 charSequence476; + Object oldString476 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(476); + if (oldString476 instanceof Utf8) { + charSequence476 = (decoder).readString(((Utf8) oldString476)); + } else { + charSequence476 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(476, charSequence476); + } else { + throw new RuntimeException(("Illegal union index for 'F476': "+ unionIndex476)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex477 = (decoder.readIndex()); + if (unionIndex477 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(477, null); + } else { + if (unionIndex477 == 1) { + Utf8 charSequence477; + Object oldString477 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(477); + if (oldString477 instanceof Utf8) { + charSequence477 = (decoder).readString(((Utf8) oldString477)); + } else { + charSequence477 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(477, charSequence477); + } else { + throw new RuntimeException(("Illegal union index for 'F477': "+ unionIndex477)); + } + } + int unionIndex478 = (decoder.readIndex()); + if (unionIndex478 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(478, null); + } else { + if (unionIndex478 == 1) { + Utf8 charSequence478; + Object oldString478 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(478); + if (oldString478 instanceof Utf8) { + charSequence478 = (decoder).readString(((Utf8) oldString478)); + } else { + charSequence478 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(478, charSequence478); + } else { + throw new RuntimeException(("Illegal union index for 'F478': "+ unionIndex478)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex479 = (decoder.readIndex()); + if (unionIndex479 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(479, null); + } else { + if (unionIndex479 == 1) { + Utf8 charSequence479; + Object oldString479 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(479); + if (oldString479 instanceof Utf8) { + charSequence479 = (decoder).readString(((Utf8) oldString479)); + } else { + charSequence479 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(479, charSequence479); + } else { + throw new RuntimeException(("Illegal union index for 'F479': "+ unionIndex479)); + } + } + int unionIndex480 = (decoder.readIndex()); + if (unionIndex480 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(480, null); + } else { + if (unionIndex480 == 1) { + Utf8 charSequence480; + Object oldString480 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(480); + if (oldString480 instanceof Utf8) { + charSequence480 = (decoder).readString(((Utf8) oldString480)); + } else { + charSequence480 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(480, charSequence480); + } else { + throw new RuntimeException(("Illegal union index for 'F480': "+ unionIndex480)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex481 = (decoder.readIndex()); + if (unionIndex481 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(481, null); + } else { + if (unionIndex481 == 1) { + Utf8 charSequence481; + Object oldString481 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(481); + if (oldString481 instanceof Utf8) { + charSequence481 = (decoder).readString(((Utf8) oldString481)); + } else { + charSequence481 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(481, charSequence481); + } else { + throw new RuntimeException(("Illegal union index for 'F481': "+ unionIndex481)); + } + } + int unionIndex482 = (decoder.readIndex()); + if (unionIndex482 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(482, null); + } else { + if (unionIndex482 == 1) { + Utf8 charSequence482; + Object oldString482 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(482); + if (oldString482 instanceof Utf8) { + charSequence482 = (decoder).readString(((Utf8) oldString482)); + } else { + charSequence482 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(482, charSequence482); + } else { + throw new RuntimeException(("Illegal union index for 'F482': "+ unionIndex482)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex483 = (decoder.readIndex()); + if (unionIndex483 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(483, null); + } else { + if (unionIndex483 == 1) { + Utf8 charSequence483; + Object oldString483 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(483); + if (oldString483 instanceof Utf8) { + charSequence483 = (decoder).readString(((Utf8) oldString483)); + } else { + charSequence483 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(483, charSequence483); + } else { + throw new RuntimeException(("Illegal union index for 'F483': "+ unionIndex483)); + } + } + int unionIndex484 = (decoder.readIndex()); + if (unionIndex484 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(484, null); + } else { + if (unionIndex484 == 1) { + Utf8 charSequence484; + Object oldString484 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(484); + if (oldString484 instanceof Utf8) { + charSequence484 = (decoder).readString(((Utf8) oldString484)); + } else { + charSequence484 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(484, charSequence484); + } else { + throw new RuntimeException(("Illegal union index for 'F484': "+ unionIndex484)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex485 = (decoder.readIndex()); + if (unionIndex485 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(485, null); + } else { + if (unionIndex485 == 1) { + Utf8 charSequence485; + Object oldString485 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(485); + if (oldString485 instanceof Utf8) { + charSequence485 = (decoder).readString(((Utf8) oldString485)); + } else { + charSequence485 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(485, charSequence485); + } else { + throw new RuntimeException(("Illegal union index for 'F485': "+ unionIndex485)); + } + } + int unionIndex486 = (decoder.readIndex()); + if (unionIndex486 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(486, null); + } else { + if (unionIndex486 == 1) { + Utf8 charSequence486; + Object oldString486 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(486); + if (oldString486 instanceof Utf8) { + charSequence486 = (decoder).readString(((Utf8) oldString486)); + } else { + charSequence486 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(486, charSequence486); + } else { + throw new RuntimeException(("Illegal union index for 'F486': "+ unionIndex486)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex487 = (decoder.readIndex()); + if (unionIndex487 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(487, null); + } else { + if (unionIndex487 == 1) { + Utf8 charSequence487; + Object oldString487 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(487); + if (oldString487 instanceof Utf8) { + charSequence487 = (decoder).readString(((Utf8) oldString487)); + } else { + charSequence487 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(487, charSequence487); + } else { + throw new RuntimeException(("Illegal union index for 'F487': "+ unionIndex487)); + } + } + int unionIndex488 = (decoder.readIndex()); + if (unionIndex488 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(488, null); + } else { + if (unionIndex488 == 1) { + Utf8 charSequence488; + Object oldString488 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(488); + if (oldString488 instanceof Utf8) { + charSequence488 = (decoder).readString(((Utf8) oldString488)); + } else { + charSequence488 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(488, charSequence488); + } else { + throw new RuntimeException(("Illegal union index for 'F488': "+ unionIndex488)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex489 = (decoder.readIndex()); + if (unionIndex489 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(489, null); + } else { + if (unionIndex489 == 1) { + Utf8 charSequence489; + Object oldString489 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(489); + if (oldString489 instanceof Utf8) { + charSequence489 = (decoder).readString(((Utf8) oldString489)); + } else { + charSequence489 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(489, charSequence489); + } else { + throw new RuntimeException(("Illegal union index for 'F489': "+ unionIndex489)); + } + } + int unionIndex490 = (decoder.readIndex()); + if (unionIndex490 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(490, null); + } else { + if (unionIndex490 == 1) { + Utf8 charSequence490; + Object oldString490 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(490); + if (oldString490 instanceof Utf8) { + charSequence490 = (decoder).readString(((Utf8) oldString490)); + } else { + charSequence490 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(490, charSequence490); + } else { + throw new RuntimeException(("Illegal union index for 'F490': "+ unionIndex490)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex491 = (decoder.readIndex()); + if (unionIndex491 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(491, null); + } else { + if (unionIndex491 == 1) { + Utf8 charSequence491; + Object oldString491 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(491); + if (oldString491 instanceof Utf8) { + charSequence491 = (decoder).readString(((Utf8) oldString491)); + } else { + charSequence491 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(491, charSequence491); + } else { + throw new RuntimeException(("Illegal union index for 'F491': "+ unionIndex491)); + } + } + int unionIndex492 = (decoder.readIndex()); + if (unionIndex492 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(492, null); + } else { + if (unionIndex492 == 1) { + Utf8 charSequence492; + Object oldString492 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(492); + if (oldString492 instanceof Utf8) { + charSequence492 = (decoder).readString(((Utf8) oldString492)); + } else { + charSequence492 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(492, charSequence492); + } else { + throw new RuntimeException(("Illegal union index for 'F492': "+ unionIndex492)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex493 = (decoder.readIndex()); + if (unionIndex493 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(493, null); + } else { + if (unionIndex493 == 1) { + Utf8 charSequence493; + Object oldString493 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(493); + if (oldString493 instanceof Utf8) { + charSequence493 = (decoder).readString(((Utf8) oldString493)); + } else { + charSequence493 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(493, charSequence493); + } else { + throw new RuntimeException(("Illegal union index for 'F493': "+ unionIndex493)); + } + } + int unionIndex494 = (decoder.readIndex()); + if (unionIndex494 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(494, null); + } else { + if (unionIndex494 == 1) { + Utf8 charSequence494; + Object oldString494 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(494); + if (oldString494 instanceof Utf8) { + charSequence494 = (decoder).readString(((Utf8) oldString494)); + } else { + charSequence494 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(494, charSequence494); + } else { + throw new RuntimeException(("Illegal union index for 'F494': "+ unionIndex494)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex495 = (decoder.readIndex()); + if (unionIndex495 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(495, null); + } else { + if (unionIndex495 == 1) { + Utf8 charSequence495; + Object oldString495 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(495); + if (oldString495 instanceof Utf8) { + charSequence495 = (decoder).readString(((Utf8) oldString495)); + } else { + charSequence495 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(495, charSequence495); + } else { + throw new RuntimeException(("Illegal union index for 'F495': "+ unionIndex495)); + } + } + int unionIndex496 = (decoder.readIndex()); + if (unionIndex496 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(496, null); + } else { + if (unionIndex496 == 1) { + Utf8 charSequence496; + Object oldString496 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(496); + if (oldString496 instanceof Utf8) { + charSequence496 = (decoder).readString(((Utf8) oldString496)); + } else { + charSequence496 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(496, charSequence496); + } else { + throw new RuntimeException(("Illegal union index for 'F496': "+ unionIndex496)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex497 = (decoder.readIndex()); + if (unionIndex497 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(497, null); + } else { + if (unionIndex497 == 1) { + Utf8 charSequence497; + Object oldString497 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(497); + if (oldString497 instanceof Utf8) { + charSequence497 = (decoder).readString(((Utf8) oldString497)); + } else { + charSequence497 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(497, charSequence497); + } else { + throw new RuntimeException(("Illegal union index for 'F497': "+ unionIndex497)); + } + } + int unionIndex498 = (decoder.readIndex()); + if (unionIndex498 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(498, null); + } else { + if (unionIndex498 == 1) { + Utf8 charSequence498; + Object oldString498 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(498); + if (oldString498 instanceof Utf8) { + charSequence498 = (decoder).readString(((Utf8) oldString498)); + } else { + charSequence498 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(498, charSequence498); + } else { + throw new RuntimeException(("Illegal union index for 'F498': "+ unionIndex498)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex499 = (decoder.readIndex()); + if (unionIndex499 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(499, null); + } else { + if (unionIndex499 == 1) { + Utf8 charSequence499; + Object oldString499 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(499); + if (oldString499 instanceof Utf8) { + charSequence499 = (decoder).readString(((Utf8) oldString499)); + } else { + charSequence499 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(499, charSequence499); + } else { + throw new RuntimeException(("Illegal union index for 'F499': "+ unionIndex499)); + } + } + int unionIndex500 = (decoder.readIndex()); + if (unionIndex500 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(500, null); + } else { + if (unionIndex500 == 1) { + Utf8 charSequence500; + Object oldString500 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(500); + if (oldString500 instanceof Utf8) { + charSequence500 = (decoder).readString(((Utf8) oldString500)); + } else { + charSequence500 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(500, charSequence500); + } else { + throw new RuntimeException(("Illegal union index for 'F500': "+ unionIndex500)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex501 = (decoder.readIndex()); + if (unionIndex501 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(501, null); + } else { + if (unionIndex501 == 1) { + Utf8 charSequence501; + Object oldString501 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(501); + if (oldString501 instanceof Utf8) { + charSequence501 = (decoder).readString(((Utf8) oldString501)); + } else { + charSequence501 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(501, charSequence501); + } else { + throw new RuntimeException(("Illegal union index for 'F501': "+ unionIndex501)); + } + } + int unionIndex502 = (decoder.readIndex()); + if (unionIndex502 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(502, null); + } else { + if (unionIndex502 == 1) { + Utf8 charSequence502; + Object oldString502 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(502); + if (oldString502 instanceof Utf8) { + charSequence502 = (decoder).readString(((Utf8) oldString502)); + } else { + charSequence502 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(502, charSequence502); + } else { + throw new RuntimeException(("Illegal union index for 'F502': "+ unionIndex502)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex503 = (decoder.readIndex()); + if (unionIndex503 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(503, null); + } else { + if (unionIndex503 == 1) { + Utf8 charSequence503; + Object oldString503 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(503); + if (oldString503 instanceof Utf8) { + charSequence503 = (decoder).readString(((Utf8) oldString503)); + } else { + charSequence503 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(503, charSequence503); + } else { + throw new RuntimeException(("Illegal union index for 'F503': "+ unionIndex503)); + } + } + int unionIndex504 = (decoder.readIndex()); + if (unionIndex504 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(504, null); + } else { + if (unionIndex504 == 1) { + Utf8 charSequence504; + Object oldString504 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(504); + if (oldString504 instanceof Utf8) { + charSequence504 = (decoder).readString(((Utf8) oldString504)); + } else { + charSequence504 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(504, charSequence504); + } else { + throw new RuntimeException(("Illegal union index for 'F504': "+ unionIndex504)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex505 = (decoder.readIndex()); + if (unionIndex505 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(505, null); + } else { + if (unionIndex505 == 1) { + Utf8 charSequence505; + Object oldString505 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(505); + if (oldString505 instanceof Utf8) { + charSequence505 = (decoder).readString(((Utf8) oldString505)); + } else { + charSequence505 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(505, charSequence505); + } else { + throw new RuntimeException(("Illegal union index for 'F505': "+ unionIndex505)); + } + } + int unionIndex506 = (decoder.readIndex()); + if (unionIndex506 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(506, null); + } else { + if (unionIndex506 == 1) { + Utf8 charSequence506; + Object oldString506 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(506); + if (oldString506 instanceof Utf8) { + charSequence506 = (decoder).readString(((Utf8) oldString506)); + } else { + charSequence506 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(506, charSequence506); + } else { + throw new RuntimeException(("Illegal union index for 'F506': "+ unionIndex506)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex507 = (decoder.readIndex()); + if (unionIndex507 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(507, null); + } else { + if (unionIndex507 == 1) { + Utf8 charSequence507; + Object oldString507 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(507); + if (oldString507 instanceof Utf8) { + charSequence507 = (decoder).readString(((Utf8) oldString507)); + } else { + charSequence507 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(507, charSequence507); + } else { + throw new RuntimeException(("Illegal union index for 'F507': "+ unionIndex507)); + } + } + int unionIndex508 = (decoder.readIndex()); + if (unionIndex508 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(508, null); + } else { + if (unionIndex508 == 1) { + Utf8 charSequence508; + Object oldString508 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(508); + if (oldString508 instanceof Utf8) { + charSequence508 = (decoder).readString(((Utf8) oldString508)); + } else { + charSequence508 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(508, charSequence508); + } else { + throw new RuntimeException(("Illegal union index for 'F508': "+ unionIndex508)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex509 = (decoder.readIndex()); + if (unionIndex509 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(509, null); + } else { + if (unionIndex509 == 1) { + Utf8 charSequence509; + Object oldString509 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(509); + if (oldString509 instanceof Utf8) { + charSequence509 = (decoder).readString(((Utf8) oldString509)); + } else { + charSequence509 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(509, charSequence509); + } else { + throw new RuntimeException(("Illegal union index for 'F509': "+ unionIndex509)); + } + } + int unionIndex510 = (decoder.readIndex()); + if (unionIndex510 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(510, null); + } else { + if (unionIndex510 == 1) { + Utf8 charSequence510; + Object oldString510 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(510); + if (oldString510 instanceof Utf8) { + charSequence510 = (decoder).readString(((Utf8) oldString510)); + } else { + charSequence510 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(510, charSequence510); + } else { + throw new RuntimeException(("Illegal union index for 'F510': "+ unionIndex510)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex511 = (decoder.readIndex()); + if (unionIndex511 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(511, null); + } else { + if (unionIndex511 == 1) { + Utf8 charSequence511; + Object oldString511 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(511); + if (oldString511 instanceof Utf8) { + charSequence511 = (decoder).readString(((Utf8) oldString511)); + } else { + charSequence511 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(511, charSequence511); + } else { + throw new RuntimeException(("Illegal union index for 'F511': "+ unionIndex511)); + } + } + int unionIndex512 = (decoder.readIndex()); + if (unionIndex512 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(512, null); + } else { + if (unionIndex512 == 1) { + Utf8 charSequence512; + Object oldString512 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(512); + if (oldString512 instanceof Utf8) { + charSequence512 = (decoder).readString(((Utf8) oldString512)); + } else { + charSequence512 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(512, charSequence512); + } else { + throw new RuntimeException(("Illegal union index for 'F512': "+ unionIndex512)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex513 = (decoder.readIndex()); + if (unionIndex513 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(513, null); + } else { + if (unionIndex513 == 1) { + Utf8 charSequence513; + Object oldString513 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(513); + if (oldString513 instanceof Utf8) { + charSequence513 = (decoder).readString(((Utf8) oldString513)); + } else { + charSequence513 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(513, charSequence513); + } else { + throw new RuntimeException(("Illegal union index for 'F513': "+ unionIndex513)); + } + } + int unionIndex514 = (decoder.readIndex()); + if (unionIndex514 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(514, null); + } else { + if (unionIndex514 == 1) { + Utf8 charSequence514; + Object oldString514 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(514); + if (oldString514 instanceof Utf8) { + charSequence514 = (decoder).readString(((Utf8) oldString514)); + } else { + charSequence514 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(514, charSequence514); + } else { + throw new RuntimeException(("Illegal union index for 'F514': "+ unionIndex514)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex515 = (decoder.readIndex()); + if (unionIndex515 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(515, null); + } else { + if (unionIndex515 == 1) { + Utf8 charSequence515; + Object oldString515 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(515); + if (oldString515 instanceof Utf8) { + charSequence515 = (decoder).readString(((Utf8) oldString515)); + } else { + charSequence515 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(515, charSequence515); + } else { + throw new RuntimeException(("Illegal union index for 'F515': "+ unionIndex515)); + } + } + int unionIndex516 = (decoder.readIndex()); + if (unionIndex516 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(516, null); + } else { + if (unionIndex516 == 1) { + Utf8 charSequence516; + Object oldString516 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(516); + if (oldString516 instanceof Utf8) { + charSequence516 = (decoder).readString(((Utf8) oldString516)); + } else { + charSequence516 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(516, charSequence516); + } else { + throw new RuntimeException(("Illegal union index for 'F516': "+ unionIndex516)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex517 = (decoder.readIndex()); + if (unionIndex517 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(517, null); + } else { + if (unionIndex517 == 1) { + Utf8 charSequence517; + Object oldString517 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(517); + if (oldString517 instanceof Utf8) { + charSequence517 = (decoder).readString(((Utf8) oldString517)); + } else { + charSequence517 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(517, charSequence517); + } else { + throw new RuntimeException(("Illegal union index for 'F517': "+ unionIndex517)); + } + } + int unionIndex518 = (decoder.readIndex()); + if (unionIndex518 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(518, null); + } else { + if (unionIndex518 == 1) { + Utf8 charSequence518; + Object oldString518 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(518); + if (oldString518 instanceof Utf8) { + charSequence518 = (decoder).readString(((Utf8) oldString518)); + } else { + charSequence518 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(518, charSequence518); + } else { + throw new RuntimeException(("Illegal union index for 'F518': "+ unionIndex518)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex519 = (decoder.readIndex()); + if (unionIndex519 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(519, null); + } else { + if (unionIndex519 == 1) { + Utf8 charSequence519; + Object oldString519 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(519); + if (oldString519 instanceof Utf8) { + charSequence519 = (decoder).readString(((Utf8) oldString519)); + } else { + charSequence519 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(519, charSequence519); + } else { + throw new RuntimeException(("Illegal union index for 'F519': "+ unionIndex519)); + } + } + int unionIndex520 = (decoder.readIndex()); + if (unionIndex520 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(520, null); + } else { + if (unionIndex520 == 1) { + Utf8 charSequence520; + Object oldString520 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(520); + if (oldString520 instanceof Utf8) { + charSequence520 = (decoder).readString(((Utf8) oldString520)); + } else { + charSequence520 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(520, charSequence520); + } else { + throw new RuntimeException(("Illegal union index for 'F520': "+ unionIndex520)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex521 = (decoder.readIndex()); + if (unionIndex521 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(521, null); + } else { + if (unionIndex521 == 1) { + Utf8 charSequence521; + Object oldString521 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(521); + if (oldString521 instanceof Utf8) { + charSequence521 = (decoder).readString(((Utf8) oldString521)); + } else { + charSequence521 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(521, charSequence521); + } else { + throw new RuntimeException(("Illegal union index for 'F521': "+ unionIndex521)); + } + } + int unionIndex522 = (decoder.readIndex()); + if (unionIndex522 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(522, null); + } else { + if (unionIndex522 == 1) { + Utf8 charSequence522; + Object oldString522 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(522); + if (oldString522 instanceof Utf8) { + charSequence522 = (decoder).readString(((Utf8) oldString522)); + } else { + charSequence522 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(522, charSequence522); + } else { + throw new RuntimeException(("Illegal union index for 'F522': "+ unionIndex522)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex523 = (decoder.readIndex()); + if (unionIndex523 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(523, null); + } else { + if (unionIndex523 == 1) { + Utf8 charSequence523; + Object oldString523 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(523); + if (oldString523 instanceof Utf8) { + charSequence523 = (decoder).readString(((Utf8) oldString523)); + } else { + charSequence523 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(523, charSequence523); + } else { + throw new RuntimeException(("Illegal union index for 'F523': "+ unionIndex523)); + } + } + int unionIndex524 = (decoder.readIndex()); + if (unionIndex524 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(524, null); + } else { + if (unionIndex524 == 1) { + Utf8 charSequence524; + Object oldString524 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(524); + if (oldString524 instanceof Utf8) { + charSequence524 = (decoder).readString(((Utf8) oldString524)); + } else { + charSequence524 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(524, charSequence524); + } else { + throw new RuntimeException(("Illegal union index for 'F524': "+ unionIndex524)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex525 = (decoder.readIndex()); + if (unionIndex525 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(525, null); + } else { + if (unionIndex525 == 1) { + Utf8 charSequence525; + Object oldString525 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(525); + if (oldString525 instanceof Utf8) { + charSequence525 = (decoder).readString(((Utf8) oldString525)); + } else { + charSequence525 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(525, charSequence525); + } else { + throw new RuntimeException(("Illegal union index for 'F525': "+ unionIndex525)); + } + } + int unionIndex526 = (decoder.readIndex()); + if (unionIndex526 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(526, null); + } else { + if (unionIndex526 == 1) { + Utf8 charSequence526; + Object oldString526 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(526); + if (oldString526 instanceof Utf8) { + charSequence526 = (decoder).readString(((Utf8) oldString526)); + } else { + charSequence526 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(526, charSequence526); + } else { + throw new RuntimeException(("Illegal union index for 'F526': "+ unionIndex526)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex527 = (decoder.readIndex()); + if (unionIndex527 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(527, null); + } else { + if (unionIndex527 == 1) { + Utf8 charSequence527; + Object oldString527 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(527); + if (oldString527 instanceof Utf8) { + charSequence527 = (decoder).readString(((Utf8) oldString527)); + } else { + charSequence527 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(527, charSequence527); + } else { + throw new RuntimeException(("Illegal union index for 'F527': "+ unionIndex527)); + } + } + int unionIndex528 = (decoder.readIndex()); + if (unionIndex528 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(528, null); + } else { + if (unionIndex528 == 1) { + Utf8 charSequence528; + Object oldString528 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(528); + if (oldString528 instanceof Utf8) { + charSequence528 = (decoder).readString(((Utf8) oldString528)); + } else { + charSequence528 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(528, charSequence528); + } else { + throw new RuntimeException(("Illegal union index for 'F528': "+ unionIndex528)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex529 = (decoder.readIndex()); + if (unionIndex529 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(529, null); + } else { + if (unionIndex529 == 1) { + Utf8 charSequence529; + Object oldString529 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(529); + if (oldString529 instanceof Utf8) { + charSequence529 = (decoder).readString(((Utf8) oldString529)); + } else { + charSequence529 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(529, charSequence529); + } else { + throw new RuntimeException(("Illegal union index for 'F529': "+ unionIndex529)); + } + } + int unionIndex530 = (decoder.readIndex()); + if (unionIndex530 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(530, null); + } else { + if (unionIndex530 == 1) { + Utf8 charSequence530; + Object oldString530 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(530); + if (oldString530 instanceof Utf8) { + charSequence530 = (decoder).readString(((Utf8) oldString530)); + } else { + charSequence530 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(530, charSequence530); + } else { + throw new RuntimeException(("Illegal union index for 'F530': "+ unionIndex530)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex531 = (decoder.readIndex()); + if (unionIndex531 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(531, null); + } else { + if (unionIndex531 == 1) { + Utf8 charSequence531; + Object oldString531 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(531); + if (oldString531 instanceof Utf8) { + charSequence531 = (decoder).readString(((Utf8) oldString531)); + } else { + charSequence531 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(531, charSequence531); + } else { + throw new RuntimeException(("Illegal union index for 'F531': "+ unionIndex531)); + } + } + int unionIndex532 = (decoder.readIndex()); + if (unionIndex532 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(532, null); + } else { + if (unionIndex532 == 1) { + Utf8 charSequence532; + Object oldString532 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(532); + if (oldString532 instanceof Utf8) { + charSequence532 = (decoder).readString(((Utf8) oldString532)); + } else { + charSequence532 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(532, charSequence532); + } else { + throw new RuntimeException(("Illegal union index for 'F532': "+ unionIndex532)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex533 = (decoder.readIndex()); + if (unionIndex533 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(533, null); + } else { + if (unionIndex533 == 1) { + Utf8 charSequence533; + Object oldString533 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(533); + if (oldString533 instanceof Utf8) { + charSequence533 = (decoder).readString(((Utf8) oldString533)); + } else { + charSequence533 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(533, charSequence533); + } else { + throw new RuntimeException(("Illegal union index for 'F533': "+ unionIndex533)); + } + } + int unionIndex534 = (decoder.readIndex()); + if (unionIndex534 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(534, null); + } else { + if (unionIndex534 == 1) { + Utf8 charSequence534; + Object oldString534 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(534); + if (oldString534 instanceof Utf8) { + charSequence534 = (decoder).readString(((Utf8) oldString534)); + } else { + charSequence534 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(534, charSequence534); + } else { + throw new RuntimeException(("Illegal union index for 'F534': "+ unionIndex534)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex535 = (decoder.readIndex()); + if (unionIndex535 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(535, null); + } else { + if (unionIndex535 == 1) { + Utf8 charSequence535; + Object oldString535 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(535); + if (oldString535 instanceof Utf8) { + charSequence535 = (decoder).readString(((Utf8) oldString535)); + } else { + charSequence535 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(535, charSequence535); + } else { + throw new RuntimeException(("Illegal union index for 'F535': "+ unionIndex535)); + } + } + int unionIndex536 = (decoder.readIndex()); + if (unionIndex536 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(536, null); + } else { + if (unionIndex536 == 1) { + Utf8 charSequence536; + Object oldString536 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(536); + if (oldString536 instanceof Utf8) { + charSequence536 = (decoder).readString(((Utf8) oldString536)); + } else { + charSequence536 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(536, charSequence536); + } else { + throw new RuntimeException(("Illegal union index for 'F536': "+ unionIndex536)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex537 = (decoder.readIndex()); + if (unionIndex537 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(537, null); + } else { + if (unionIndex537 == 1) { + Utf8 charSequence537; + Object oldString537 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(537); + if (oldString537 instanceof Utf8) { + charSequence537 = (decoder).readString(((Utf8) oldString537)); + } else { + charSequence537 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(537, charSequence537); + } else { + throw new RuntimeException(("Illegal union index for 'F537': "+ unionIndex537)); + } + } + int unionIndex538 = (decoder.readIndex()); + if (unionIndex538 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(538, null); + } else { + if (unionIndex538 == 1) { + Utf8 charSequence538; + Object oldString538 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(538); + if (oldString538 instanceof Utf8) { + charSequence538 = (decoder).readString(((Utf8) oldString538)); + } else { + charSequence538 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(538, charSequence538); + } else { + throw new RuntimeException(("Illegal union index for 'F538': "+ unionIndex538)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex539 = (decoder.readIndex()); + if (unionIndex539 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(539, null); + } else { + if (unionIndex539 == 1) { + Utf8 charSequence539; + Object oldString539 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(539); + if (oldString539 instanceof Utf8) { + charSequence539 = (decoder).readString(((Utf8) oldString539)); + } else { + charSequence539 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(539, charSequence539); + } else { + throw new RuntimeException(("Illegal union index for 'F539': "+ unionIndex539)); + } + } + int unionIndex540 = (decoder.readIndex()); + if (unionIndex540 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(540, null); + } else { + if (unionIndex540 == 1) { + Utf8 charSequence540; + Object oldString540 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(540); + if (oldString540 instanceof Utf8) { + charSequence540 = (decoder).readString(((Utf8) oldString540)); + } else { + charSequence540 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(540, charSequence540); + } else { + throw new RuntimeException(("Illegal union index for 'F540': "+ unionIndex540)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex541 = (decoder.readIndex()); + if (unionIndex541 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(541, null); + } else { + if (unionIndex541 == 1) { + Utf8 charSequence541; + Object oldString541 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(541); + if (oldString541 instanceof Utf8) { + charSequence541 = (decoder).readString(((Utf8) oldString541)); + } else { + charSequence541 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(541, charSequence541); + } else { + throw new RuntimeException(("Illegal union index for 'F541': "+ unionIndex541)); + } + } + int unionIndex542 = (decoder.readIndex()); + if (unionIndex542 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(542, null); + } else { + if (unionIndex542 == 1) { + Utf8 charSequence542; + Object oldString542 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(542); + if (oldString542 instanceof Utf8) { + charSequence542 = (decoder).readString(((Utf8) oldString542)); + } else { + charSequence542 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(542, charSequence542); + } else { + throw new RuntimeException(("Illegal union index for 'F542': "+ unionIndex542)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex543 = (decoder.readIndex()); + if (unionIndex543 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(543, null); + } else { + if (unionIndex543 == 1) { + Utf8 charSequence543; + Object oldString543 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(543); + if (oldString543 instanceof Utf8) { + charSequence543 = (decoder).readString(((Utf8) oldString543)); + } else { + charSequence543 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(543, charSequence543); + } else { + throw new RuntimeException(("Illegal union index for 'F543': "+ unionIndex543)); + } + } + int unionIndex544 = (decoder.readIndex()); + if (unionIndex544 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(544, null); + } else { + if (unionIndex544 == 1) { + Utf8 charSequence544; + Object oldString544 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(544); + if (oldString544 instanceof Utf8) { + charSequence544 = (decoder).readString(((Utf8) oldString544)); + } else { + charSequence544 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(544, charSequence544); + } else { + throw new RuntimeException(("Illegal union index for 'F544': "+ unionIndex544)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex545 = (decoder.readIndex()); + if (unionIndex545 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(545, null); + } else { + if (unionIndex545 == 1) { + Utf8 charSequence545; + Object oldString545 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(545); + if (oldString545 instanceof Utf8) { + charSequence545 = (decoder).readString(((Utf8) oldString545)); + } else { + charSequence545 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(545, charSequence545); + } else { + throw new RuntimeException(("Illegal union index for 'F545': "+ unionIndex545)); + } + } + int unionIndex546 = (decoder.readIndex()); + if (unionIndex546 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(546, null); + } else { + if (unionIndex546 == 1) { + Utf8 charSequence546; + Object oldString546 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(546); + if (oldString546 instanceof Utf8) { + charSequence546 = (decoder).readString(((Utf8) oldString546)); + } else { + charSequence546 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(546, charSequence546); + } else { + throw new RuntimeException(("Illegal union index for 'F546': "+ unionIndex546)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex547 = (decoder.readIndex()); + if (unionIndex547 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(547, null); + } else { + if (unionIndex547 == 1) { + Utf8 charSequence547; + Object oldString547 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(547); + if (oldString547 instanceof Utf8) { + charSequence547 = (decoder).readString(((Utf8) oldString547)); + } else { + charSequence547 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(547, charSequence547); + } else { + throw new RuntimeException(("Illegal union index for 'F547': "+ unionIndex547)); + } + } + int unionIndex548 = (decoder.readIndex()); + if (unionIndex548 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(548, null); + } else { + if (unionIndex548 == 1) { + Utf8 charSequence548; + Object oldString548 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(548); + if (oldString548 instanceof Utf8) { + charSequence548 = (decoder).readString(((Utf8) oldString548)); + } else { + charSequence548 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(548, charSequence548); + } else { + throw new RuntimeException(("Illegal union index for 'F548': "+ unionIndex548)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex549 = (decoder.readIndex()); + if (unionIndex549 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(549, null); + } else { + if (unionIndex549 == 1) { + Utf8 charSequence549; + Object oldString549 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(549); + if (oldString549 instanceof Utf8) { + charSequence549 = (decoder).readString(((Utf8) oldString549)); + } else { + charSequence549 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(549, charSequence549); + } else { + throw new RuntimeException(("Illegal union index for 'F549': "+ unionIndex549)); + } + } + int unionIndex550 = (decoder.readIndex()); + if (unionIndex550 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(550, null); + } else { + if (unionIndex550 == 1) { + Utf8 charSequence550; + Object oldString550 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(550); + if (oldString550 instanceof Utf8) { + charSequence550 = (decoder).readString(((Utf8) oldString550)); + } else { + charSequence550 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(550, charSequence550); + } else { + throw new RuntimeException(("Illegal union index for 'F550': "+ unionIndex550)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex551 = (decoder.readIndex()); + if (unionIndex551 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(551, null); + } else { + if (unionIndex551 == 1) { + Utf8 charSequence551; + Object oldString551 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(551); + if (oldString551 instanceof Utf8) { + charSequence551 = (decoder).readString(((Utf8) oldString551)); + } else { + charSequence551 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(551, charSequence551); + } else { + throw new RuntimeException(("Illegal union index for 'F551': "+ unionIndex551)); + } + } + int unionIndex552 = (decoder.readIndex()); + if (unionIndex552 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(552, null); + } else { + if (unionIndex552 == 1) { + Utf8 charSequence552; + Object oldString552 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(552); + if (oldString552 instanceof Utf8) { + charSequence552 = (decoder).readString(((Utf8) oldString552)); + } else { + charSequence552 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(552, charSequence552); + } else { + throw new RuntimeException(("Illegal union index for 'F552': "+ unionIndex552)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex553 = (decoder.readIndex()); + if (unionIndex553 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(553, null); + } else { + if (unionIndex553 == 1) { + Utf8 charSequence553; + Object oldString553 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(553); + if (oldString553 instanceof Utf8) { + charSequence553 = (decoder).readString(((Utf8) oldString553)); + } else { + charSequence553 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(553, charSequence553); + } else { + throw new RuntimeException(("Illegal union index for 'F553': "+ unionIndex553)); + } + } + int unionIndex554 = (decoder.readIndex()); + if (unionIndex554 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(554, null); + } else { + if (unionIndex554 == 1) { + Utf8 charSequence554; + Object oldString554 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(554); + if (oldString554 instanceof Utf8) { + charSequence554 = (decoder).readString(((Utf8) oldString554)); + } else { + charSequence554 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(554, charSequence554); + } else { + throw new RuntimeException(("Illegal union index for 'F554': "+ unionIndex554)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex555 = (decoder.readIndex()); + if (unionIndex555 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(555, null); + } else { + if (unionIndex555 == 1) { + Utf8 charSequence555; + Object oldString555 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(555); + if (oldString555 instanceof Utf8) { + charSequence555 = (decoder).readString(((Utf8) oldString555)); + } else { + charSequence555 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(555, charSequence555); + } else { + throw new RuntimeException(("Illegal union index for 'F555': "+ unionIndex555)); + } + } + int unionIndex556 = (decoder.readIndex()); + if (unionIndex556 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(556, null); + } else { + if (unionIndex556 == 1) { + Utf8 charSequence556; + Object oldString556 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(556); + if (oldString556 instanceof Utf8) { + charSequence556 = (decoder).readString(((Utf8) oldString556)); + } else { + charSequence556 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(556, charSequence556); + } else { + throw new RuntimeException(("Illegal union index for 'F556': "+ unionIndex556)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex557 = (decoder.readIndex()); + if (unionIndex557 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(557, null); + } else { + if (unionIndex557 == 1) { + Utf8 charSequence557; + Object oldString557 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(557); + if (oldString557 instanceof Utf8) { + charSequence557 = (decoder).readString(((Utf8) oldString557)); + } else { + charSequence557 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(557, charSequence557); + } else { + throw new RuntimeException(("Illegal union index for 'F557': "+ unionIndex557)); + } + } + int unionIndex558 = (decoder.readIndex()); + if (unionIndex558 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(558, null); + } else { + if (unionIndex558 == 1) { + Utf8 charSequence558; + Object oldString558 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(558); + if (oldString558 instanceof Utf8) { + charSequence558 = (decoder).readString(((Utf8) oldString558)); + } else { + charSequence558 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(558, charSequence558); + } else { + throw new RuntimeException(("Illegal union index for 'F558': "+ unionIndex558)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex559 = (decoder.readIndex()); + if (unionIndex559 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(559, null); + } else { + if (unionIndex559 == 1) { + Utf8 charSequence559; + Object oldString559 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(559); + if (oldString559 instanceof Utf8) { + charSequence559 = (decoder).readString(((Utf8) oldString559)); + } else { + charSequence559 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(559, charSequence559); + } else { + throw new RuntimeException(("Illegal union index for 'F559': "+ unionIndex559)); + } + } + int unionIndex560 = (decoder.readIndex()); + if (unionIndex560 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(560, null); + } else { + if (unionIndex560 == 1) { + Utf8 charSequence560; + Object oldString560 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(560); + if (oldString560 instanceof Utf8) { + charSequence560 = (decoder).readString(((Utf8) oldString560)); + } else { + charSequence560 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(560, charSequence560); + } else { + throw new RuntimeException(("Illegal union index for 'F560': "+ unionIndex560)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex561 = (decoder.readIndex()); + if (unionIndex561 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(561, null); + } else { + if (unionIndex561 == 1) { + Utf8 charSequence561; + Object oldString561 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(561); + if (oldString561 instanceof Utf8) { + charSequence561 = (decoder).readString(((Utf8) oldString561)); + } else { + charSequence561 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(561, charSequence561); + } else { + throw new RuntimeException(("Illegal union index for 'F561': "+ unionIndex561)); + } + } + int unionIndex562 = (decoder.readIndex()); + if (unionIndex562 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(562, null); + } else { + if (unionIndex562 == 1) { + Utf8 charSequence562; + Object oldString562 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(562); + if (oldString562 instanceof Utf8) { + charSequence562 = (decoder).readString(((Utf8) oldString562)); + } else { + charSequence562 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(562, charSequence562); + } else { + throw new RuntimeException(("Illegal union index for 'F562': "+ unionIndex562)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex563 = (decoder.readIndex()); + if (unionIndex563 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(563, null); + } else { + if (unionIndex563 == 1) { + Utf8 charSequence563; + Object oldString563 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(563); + if (oldString563 instanceof Utf8) { + charSequence563 = (decoder).readString(((Utf8) oldString563)); + } else { + charSequence563 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(563, charSequence563); + } else { + throw new RuntimeException(("Illegal union index for 'F563': "+ unionIndex563)); + } + } + int unionIndex564 = (decoder.readIndex()); + if (unionIndex564 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(564, null); + } else { + if (unionIndex564 == 1) { + Utf8 charSequence564; + Object oldString564 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(564); + if (oldString564 instanceof Utf8) { + charSequence564 = (decoder).readString(((Utf8) oldString564)); + } else { + charSequence564 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(564, charSequence564); + } else { + throw new RuntimeException(("Illegal union index for 'F564': "+ unionIndex564)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex565 = (decoder.readIndex()); + if (unionIndex565 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(565, null); + } else { + if (unionIndex565 == 1) { + Utf8 charSequence565; + Object oldString565 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(565); + if (oldString565 instanceof Utf8) { + charSequence565 = (decoder).readString(((Utf8) oldString565)); + } else { + charSequence565 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(565, charSequence565); + } else { + throw new RuntimeException(("Illegal union index for 'F565': "+ unionIndex565)); + } + } + int unionIndex566 = (decoder.readIndex()); + if (unionIndex566 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(566, null); + } else { + if (unionIndex566 == 1) { + Utf8 charSequence566; + Object oldString566 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(566); + if (oldString566 instanceof Utf8) { + charSequence566 = (decoder).readString(((Utf8) oldString566)); + } else { + charSequence566 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(566, charSequence566); + } else { + throw new RuntimeException(("Illegal union index for 'F566': "+ unionIndex566)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex567 = (decoder.readIndex()); + if (unionIndex567 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(567, null); + } else { + if (unionIndex567 == 1) { + Utf8 charSequence567; + Object oldString567 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(567); + if (oldString567 instanceof Utf8) { + charSequence567 = (decoder).readString(((Utf8) oldString567)); + } else { + charSequence567 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(567, charSequence567); + } else { + throw new RuntimeException(("Illegal union index for 'F567': "+ unionIndex567)); + } + } + int unionIndex568 = (decoder.readIndex()); + if (unionIndex568 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(568, null); + } else { + if (unionIndex568 == 1) { + Utf8 charSequence568; + Object oldString568 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(568); + if (oldString568 instanceof Utf8) { + charSequence568 = (decoder).readString(((Utf8) oldString568)); + } else { + charSequence568 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(568, charSequence568); + } else { + throw new RuntimeException(("Illegal union index for 'F568': "+ unionIndex568)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex569 = (decoder.readIndex()); + if (unionIndex569 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(569, null); + } else { + if (unionIndex569 == 1) { + Utf8 charSequence569; + Object oldString569 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(569); + if (oldString569 instanceof Utf8) { + charSequence569 = (decoder).readString(((Utf8) oldString569)); + } else { + charSequence569 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(569, charSequence569); + } else { + throw new RuntimeException(("Illegal union index for 'F569': "+ unionIndex569)); + } + } + int unionIndex570 = (decoder.readIndex()); + if (unionIndex570 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(570, null); + } else { + if (unionIndex570 == 1) { + Utf8 charSequence570; + Object oldString570 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(570); + if (oldString570 instanceof Utf8) { + charSequence570 = (decoder).readString(((Utf8) oldString570)); + } else { + charSequence570 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(570, charSequence570); + } else { + throw new RuntimeException(("Illegal union index for 'F570': "+ unionIndex570)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex571 = (decoder.readIndex()); + if (unionIndex571 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(571, null); + } else { + if (unionIndex571 == 1) { + Utf8 charSequence571; + Object oldString571 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(571); + if (oldString571 instanceof Utf8) { + charSequence571 = (decoder).readString(((Utf8) oldString571)); + } else { + charSequence571 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(571, charSequence571); + } else { + throw new RuntimeException(("Illegal union index for 'F571': "+ unionIndex571)); + } + } + int unionIndex572 = (decoder.readIndex()); + if (unionIndex572 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(572, null); + } else { + if (unionIndex572 == 1) { + Utf8 charSequence572; + Object oldString572 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(572); + if (oldString572 instanceof Utf8) { + charSequence572 = (decoder).readString(((Utf8) oldString572)); + } else { + charSequence572 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(572, charSequence572); + } else { + throw new RuntimeException(("Illegal union index for 'F572': "+ unionIndex572)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex573 = (decoder.readIndex()); + if (unionIndex573 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(573, null); + } else { + if (unionIndex573 == 1) { + Utf8 charSequence573; + Object oldString573 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(573); + if (oldString573 instanceof Utf8) { + charSequence573 = (decoder).readString(((Utf8) oldString573)); + } else { + charSequence573 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(573, charSequence573); + } else { + throw new RuntimeException(("Illegal union index for 'F573': "+ unionIndex573)); + } + } + int unionIndex574 = (decoder.readIndex()); + if (unionIndex574 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(574, null); + } else { + if (unionIndex574 == 1) { + Utf8 charSequence574; + Object oldString574 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(574); + if (oldString574 instanceof Utf8) { + charSequence574 = (decoder).readString(((Utf8) oldString574)); + } else { + charSequence574 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(574, charSequence574); + } else { + throw new RuntimeException(("Illegal union index for 'F574': "+ unionIndex574)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex575 = (decoder.readIndex()); + if (unionIndex575 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(575, null); + } else { + if (unionIndex575 == 1) { + Utf8 charSequence575; + Object oldString575 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(575); + if (oldString575 instanceof Utf8) { + charSequence575 = (decoder).readString(((Utf8) oldString575)); + } else { + charSequence575 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(575, charSequence575); + } else { + throw new RuntimeException(("Illegal union index for 'F575': "+ unionIndex575)); + } + } + int unionIndex576 = (decoder.readIndex()); + if (unionIndex576 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(576, null); + } else { + if (unionIndex576 == 1) { + Utf8 charSequence576; + Object oldString576 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(576); + if (oldString576 instanceof Utf8) { + charSequence576 = (decoder).readString(((Utf8) oldString576)); + } else { + charSequence576 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(576, charSequence576); + } else { + throw new RuntimeException(("Illegal union index for 'F576': "+ unionIndex576)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex577 = (decoder.readIndex()); + if (unionIndex577 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(577, null); + } else { + if (unionIndex577 == 1) { + Utf8 charSequence577; + Object oldString577 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(577); + if (oldString577 instanceof Utf8) { + charSequence577 = (decoder).readString(((Utf8) oldString577)); + } else { + charSequence577 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(577, charSequence577); + } else { + throw new RuntimeException(("Illegal union index for 'F577': "+ unionIndex577)); + } + } + int unionIndex578 = (decoder.readIndex()); + if (unionIndex578 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(578, null); + } else { + if (unionIndex578 == 1) { + Utf8 charSequence578; + Object oldString578 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(578); + if (oldString578 instanceof Utf8) { + charSequence578 = (decoder).readString(((Utf8) oldString578)); + } else { + charSequence578 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(578, charSequence578); + } else { + throw new RuntimeException(("Illegal union index for 'F578': "+ unionIndex578)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex579 = (decoder.readIndex()); + if (unionIndex579 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(579, null); + } else { + if (unionIndex579 == 1) { + Utf8 charSequence579; + Object oldString579 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(579); + if (oldString579 instanceof Utf8) { + charSequence579 = (decoder).readString(((Utf8) oldString579)); + } else { + charSequence579 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(579, charSequence579); + } else { + throw new RuntimeException(("Illegal union index for 'F579': "+ unionIndex579)); + } + } + int unionIndex580 = (decoder.readIndex()); + if (unionIndex580 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(580, null); + } else { + if (unionIndex580 == 1) { + Utf8 charSequence580; + Object oldString580 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(580); + if (oldString580 instanceof Utf8) { + charSequence580 = (decoder).readString(((Utf8) oldString580)); + } else { + charSequence580 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(580, charSequence580); + } else { + throw new RuntimeException(("Illegal union index for 'F580': "+ unionIndex580)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex581 = (decoder.readIndex()); + if (unionIndex581 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(581, null); + } else { + if (unionIndex581 == 1) { + Utf8 charSequence581; + Object oldString581 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(581); + if (oldString581 instanceof Utf8) { + charSequence581 = (decoder).readString(((Utf8) oldString581)); + } else { + charSequence581 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(581, charSequence581); + } else { + throw new RuntimeException(("Illegal union index for 'F581': "+ unionIndex581)); + } + } + int unionIndex582 = (decoder.readIndex()); + if (unionIndex582 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(582, null); + } else { + if (unionIndex582 == 1) { + Utf8 charSequence582; + Object oldString582 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(582); + if (oldString582 instanceof Utf8) { + charSequence582 = (decoder).readString(((Utf8) oldString582)); + } else { + charSequence582 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(582, charSequence582); + } else { + throw new RuntimeException(("Illegal union index for 'F582': "+ unionIndex582)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex583 = (decoder.readIndex()); + if (unionIndex583 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(583, null); + } else { + if (unionIndex583 == 1) { + Utf8 charSequence583; + Object oldString583 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(583); + if (oldString583 instanceof Utf8) { + charSequence583 = (decoder).readString(((Utf8) oldString583)); + } else { + charSequence583 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(583, charSequence583); + } else { + throw new RuntimeException(("Illegal union index for 'F583': "+ unionIndex583)); + } + } + int unionIndex584 = (decoder.readIndex()); + if (unionIndex584 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(584, null); + } else { + if (unionIndex584 == 1) { + Utf8 charSequence584; + Object oldString584 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(584); + if (oldString584 instanceof Utf8) { + charSequence584 = (decoder).readString(((Utf8) oldString584)); + } else { + charSequence584 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(584, charSequence584); + } else { + throw new RuntimeException(("Illegal union index for 'F584': "+ unionIndex584)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex585 = (decoder.readIndex()); + if (unionIndex585 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(585, null); + } else { + if (unionIndex585 == 1) { + Utf8 charSequence585; + Object oldString585 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(585); + if (oldString585 instanceof Utf8) { + charSequence585 = (decoder).readString(((Utf8) oldString585)); + } else { + charSequence585 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(585, charSequence585); + } else { + throw new RuntimeException(("Illegal union index for 'F585': "+ unionIndex585)); + } + } + int unionIndex586 = (decoder.readIndex()); + if (unionIndex586 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(586, null); + } else { + if (unionIndex586 == 1) { + Utf8 charSequence586; + Object oldString586 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(586); + if (oldString586 instanceof Utf8) { + charSequence586 = (decoder).readString(((Utf8) oldString586)); + } else { + charSequence586 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(586, charSequence586); + } else { + throw new RuntimeException(("Illegal union index for 'F586': "+ unionIndex586)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex587 = (decoder.readIndex()); + if (unionIndex587 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(587, null); + } else { + if (unionIndex587 == 1) { + Utf8 charSequence587; + Object oldString587 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(587); + if (oldString587 instanceof Utf8) { + charSequence587 = (decoder).readString(((Utf8) oldString587)); + } else { + charSequence587 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(587, charSequence587); + } else { + throw new RuntimeException(("Illegal union index for 'F587': "+ unionIndex587)); + } + } + int unionIndex588 = (decoder.readIndex()); + if (unionIndex588 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(588, null); + } else { + if (unionIndex588 == 1) { + Utf8 charSequence588; + Object oldString588 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(588); + if (oldString588 instanceof Utf8) { + charSequence588 = (decoder).readString(((Utf8) oldString588)); + } else { + charSequence588 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(588, charSequence588); + } else { + throw new RuntimeException(("Illegal union index for 'F588': "+ unionIndex588)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex589 = (decoder.readIndex()); + if (unionIndex589 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(589, null); + } else { + if (unionIndex589 == 1) { + Utf8 charSequence589; + Object oldString589 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(589); + if (oldString589 instanceof Utf8) { + charSequence589 = (decoder).readString(((Utf8) oldString589)); + } else { + charSequence589 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(589, charSequence589); + } else { + throw new RuntimeException(("Illegal union index for 'F589': "+ unionIndex589)); + } + } + int unionIndex590 = (decoder.readIndex()); + if (unionIndex590 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(590, null); + } else { + if (unionIndex590 == 1) { + Utf8 charSequence590; + Object oldString590 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(590); + if (oldString590 instanceof Utf8) { + charSequence590 = (decoder).readString(((Utf8) oldString590)); + } else { + charSequence590 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(590, charSequence590); + } else { + throw new RuntimeException(("Illegal union index for 'F590': "+ unionIndex590)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex591 = (decoder.readIndex()); + if (unionIndex591 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(591, null); + } else { + if (unionIndex591 == 1) { + Utf8 charSequence591; + Object oldString591 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(591); + if (oldString591 instanceof Utf8) { + charSequence591 = (decoder).readString(((Utf8) oldString591)); + } else { + charSequence591 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(591, charSequence591); + } else { + throw new RuntimeException(("Illegal union index for 'F591': "+ unionIndex591)); + } + } + int unionIndex592 = (decoder.readIndex()); + if (unionIndex592 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(592, null); + } else { + if (unionIndex592 == 1) { + Utf8 charSequence592; + Object oldString592 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(592); + if (oldString592 instanceof Utf8) { + charSequence592 = (decoder).readString(((Utf8) oldString592)); + } else { + charSequence592 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(592, charSequence592); + } else { + throw new RuntimeException(("Illegal union index for 'F592': "+ unionIndex592)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex593 = (decoder.readIndex()); + if (unionIndex593 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(593, null); + } else { + if (unionIndex593 == 1) { + Utf8 charSequence593; + Object oldString593 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(593); + if (oldString593 instanceof Utf8) { + charSequence593 = (decoder).readString(((Utf8) oldString593)); + } else { + charSequence593 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(593, charSequence593); + } else { + throw new RuntimeException(("Illegal union index for 'F593': "+ unionIndex593)); + } + } + int unionIndex594 = (decoder.readIndex()); + if (unionIndex594 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(594, null); + } else { + if (unionIndex594 == 1) { + Utf8 charSequence594; + Object oldString594 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(594); + if (oldString594 instanceof Utf8) { + charSequence594 = (decoder).readString(((Utf8) oldString594)); + } else { + charSequence594 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(594, charSequence594); + } else { + throw new RuntimeException(("Illegal union index for 'F594': "+ unionIndex594)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex595 = (decoder.readIndex()); + if (unionIndex595 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(595, null); + } else { + if (unionIndex595 == 1) { + Utf8 charSequence595; + Object oldString595 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(595); + if (oldString595 instanceof Utf8) { + charSequence595 = (decoder).readString(((Utf8) oldString595)); + } else { + charSequence595 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(595, charSequence595); + } else { + throw new RuntimeException(("Illegal union index for 'F595': "+ unionIndex595)); + } + } + int unionIndex596 = (decoder.readIndex()); + if (unionIndex596 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(596, null); + } else { + if (unionIndex596 == 1) { + Utf8 charSequence596; + Object oldString596 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(596); + if (oldString596 instanceof Utf8) { + charSequence596 = (decoder).readString(((Utf8) oldString596)); + } else { + charSequence596 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(596, charSequence596); + } else { + throw new RuntimeException(("Illegal union index for 'F596': "+ unionIndex596)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex597 = (decoder.readIndex()); + if (unionIndex597 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(597, null); + } else { + if (unionIndex597 == 1) { + Utf8 charSequence597; + Object oldString597 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(597); + if (oldString597 instanceof Utf8) { + charSequence597 = (decoder).readString(((Utf8) oldString597)); + } else { + charSequence597 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(597, charSequence597); + } else { + throw new RuntimeException(("Illegal union index for 'F597': "+ unionIndex597)); + } + } + int unionIndex598 = (decoder.readIndex()); + if (unionIndex598 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(598, null); + } else { + if (unionIndex598 == 1) { + Utf8 charSequence598; + Object oldString598 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(598); + if (oldString598 instanceof Utf8) { + charSequence598 = (decoder).readString(((Utf8) oldString598)); + } else { + charSequence598 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(598, charSequence598); + } else { + throw new RuntimeException(("Illegal union index for 'F598': "+ unionIndex598)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex599 = (decoder.readIndex()); + if (unionIndex599 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(599, null); + } else { + if (unionIndex599 == 1) { + Utf8 charSequence599; + Object oldString599 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(599); + if (oldString599 instanceof Utf8) { + charSequence599 = (decoder).readString(((Utf8) oldString599)); + } else { + charSequence599 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(599, charSequence599); + } else { + throw new RuntimeException(("Illegal union index for 'F599': "+ unionIndex599)); + } + } + int unionIndex600 = (decoder.readIndex()); + if (unionIndex600 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(600, null); + } else { + if (unionIndex600 == 1) { + Utf8 charSequence600; + Object oldString600 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(600); + if (oldString600 instanceof Utf8) { + charSequence600 = (decoder).readString(((Utf8) oldString600)); + } else { + charSequence600 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(600, charSequence600); + } else { + throw new RuntimeException(("Illegal union index for 'F600': "+ unionIndex600)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex601 = (decoder.readIndex()); + if (unionIndex601 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(601, null); + } else { + if (unionIndex601 == 1) { + Utf8 charSequence601; + Object oldString601 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(601); + if (oldString601 instanceof Utf8) { + charSequence601 = (decoder).readString(((Utf8) oldString601)); + } else { + charSequence601 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(601, charSequence601); + } else { + throw new RuntimeException(("Illegal union index for 'F601': "+ unionIndex601)); + } + } + int unionIndex602 = (decoder.readIndex()); + if (unionIndex602 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(602, null); + } else { + if (unionIndex602 == 1) { + Utf8 charSequence602; + Object oldString602 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(602); + if (oldString602 instanceof Utf8) { + charSequence602 = (decoder).readString(((Utf8) oldString602)); + } else { + charSequence602 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(602, charSequence602); + } else { + throw new RuntimeException(("Illegal union index for 'F602': "+ unionIndex602)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex603 = (decoder.readIndex()); + if (unionIndex603 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(603, null); + } else { + if (unionIndex603 == 1) { + Utf8 charSequence603; + Object oldString603 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(603); + if (oldString603 instanceof Utf8) { + charSequence603 = (decoder).readString(((Utf8) oldString603)); + } else { + charSequence603 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(603, charSequence603); + } else { + throw new RuntimeException(("Illegal union index for 'F603': "+ unionIndex603)); + } + } + int unionIndex604 = (decoder.readIndex()); + if (unionIndex604 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(604, null); + } else { + if (unionIndex604 == 1) { + Utf8 charSequence604; + Object oldString604 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(604); + if (oldString604 instanceof Utf8) { + charSequence604 = (decoder).readString(((Utf8) oldString604)); + } else { + charSequence604 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(604, charSequence604); + } else { + throw new RuntimeException(("Illegal union index for 'F604': "+ unionIndex604)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex605 = (decoder.readIndex()); + if (unionIndex605 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(605, null); + } else { + if (unionIndex605 == 1) { + Utf8 charSequence605; + Object oldString605 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(605); + if (oldString605 instanceof Utf8) { + charSequence605 = (decoder).readString(((Utf8) oldString605)); + } else { + charSequence605 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(605, charSequence605); + } else { + throw new RuntimeException(("Illegal union index for 'F605': "+ unionIndex605)); + } + } + int unionIndex606 = (decoder.readIndex()); + if (unionIndex606 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(606, null); + } else { + if (unionIndex606 == 1) { + Utf8 charSequence606; + Object oldString606 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(606); + if (oldString606 instanceof Utf8) { + charSequence606 = (decoder).readString(((Utf8) oldString606)); + } else { + charSequence606 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(606, charSequence606); + } else { + throw new RuntimeException(("Illegal union index for 'F606': "+ unionIndex606)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex607 = (decoder.readIndex()); + if (unionIndex607 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(607, null); + } else { + if (unionIndex607 == 1) { + Utf8 charSequence607; + Object oldString607 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(607); + if (oldString607 instanceof Utf8) { + charSequence607 = (decoder).readString(((Utf8) oldString607)); + } else { + charSequence607 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(607, charSequence607); + } else { + throw new RuntimeException(("Illegal union index for 'F607': "+ unionIndex607)); + } + } + int unionIndex608 = (decoder.readIndex()); + if (unionIndex608 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(608, null); + } else { + if (unionIndex608 == 1) { + Utf8 charSequence608; + Object oldString608 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(608); + if (oldString608 instanceof Utf8) { + charSequence608 = (decoder).readString(((Utf8) oldString608)); + } else { + charSequence608 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(608, charSequence608); + } else { + throw new RuntimeException(("Illegal union index for 'F608': "+ unionIndex608)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex609 = (decoder.readIndex()); + if (unionIndex609 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(609, null); + } else { + if (unionIndex609 == 1) { + Utf8 charSequence609; + Object oldString609 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(609); + if (oldString609 instanceof Utf8) { + charSequence609 = (decoder).readString(((Utf8) oldString609)); + } else { + charSequence609 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(609, charSequence609); + } else { + throw new RuntimeException(("Illegal union index for 'F609': "+ unionIndex609)); + } + } + int unionIndex610 = (decoder.readIndex()); + if (unionIndex610 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(610, null); + } else { + if (unionIndex610 == 1) { + Utf8 charSequence610; + Object oldString610 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(610); + if (oldString610 instanceof Utf8) { + charSequence610 = (decoder).readString(((Utf8) oldString610)); + } else { + charSequence610 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(610, charSequence610); + } else { + throw new RuntimeException(("Illegal union index for 'F610': "+ unionIndex610)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex611 = (decoder.readIndex()); + if (unionIndex611 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(611, null); + } else { + if (unionIndex611 == 1) { + Utf8 charSequence611; + Object oldString611 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(611); + if (oldString611 instanceof Utf8) { + charSequence611 = (decoder).readString(((Utf8) oldString611)); + } else { + charSequence611 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(611, charSequence611); + } else { + throw new RuntimeException(("Illegal union index for 'F611': "+ unionIndex611)); + } + } + int unionIndex612 = (decoder.readIndex()); + if (unionIndex612 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(612, null); + } else { + if (unionIndex612 == 1) { + Utf8 charSequence612; + Object oldString612 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(612); + if (oldString612 instanceof Utf8) { + charSequence612 = (decoder).readString(((Utf8) oldString612)); + } else { + charSequence612 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(612, charSequence612); + } else { + throw new RuntimeException(("Illegal union index for 'F612': "+ unionIndex612)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex613 = (decoder.readIndex()); + if (unionIndex613 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(613, null); + } else { + if (unionIndex613 == 1) { + Utf8 charSequence613; + Object oldString613 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(613); + if (oldString613 instanceof Utf8) { + charSequence613 = (decoder).readString(((Utf8) oldString613)); + } else { + charSequence613 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(613, charSequence613); + } else { + throw new RuntimeException(("Illegal union index for 'F613': "+ unionIndex613)); + } + } + int unionIndex614 = (decoder.readIndex()); + if (unionIndex614 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(614, null); + } else { + if (unionIndex614 == 1) { + Utf8 charSequence614; + Object oldString614 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(614); + if (oldString614 instanceof Utf8) { + charSequence614 = (decoder).readString(((Utf8) oldString614)); + } else { + charSequence614 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(614, charSequence614); + } else { + throw new RuntimeException(("Illegal union index for 'F614': "+ unionIndex614)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex615 = (decoder.readIndex()); + if (unionIndex615 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(615, null); + } else { + if (unionIndex615 == 1) { + Utf8 charSequence615; + Object oldString615 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(615); + if (oldString615 instanceof Utf8) { + charSequence615 = (decoder).readString(((Utf8) oldString615)); + } else { + charSequence615 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(615, charSequence615); + } else { + throw new RuntimeException(("Illegal union index for 'F615': "+ unionIndex615)); + } + } + int unionIndex616 = (decoder.readIndex()); + if (unionIndex616 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(616, null); + } else { + if (unionIndex616 == 1) { + Utf8 charSequence616; + Object oldString616 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(616); + if (oldString616 instanceof Utf8) { + charSequence616 = (decoder).readString(((Utf8) oldString616)); + } else { + charSequence616 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(616, charSequence616); + } else { + throw new RuntimeException(("Illegal union index for 'F616': "+ unionIndex616)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex617 = (decoder.readIndex()); + if (unionIndex617 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(617, null); + } else { + if (unionIndex617 == 1) { + Utf8 charSequence617; + Object oldString617 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(617); + if (oldString617 instanceof Utf8) { + charSequence617 = (decoder).readString(((Utf8) oldString617)); + } else { + charSequence617 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(617, charSequence617); + } else { + throw new RuntimeException(("Illegal union index for 'F617': "+ unionIndex617)); + } + } + int unionIndex618 = (decoder.readIndex()); + if (unionIndex618 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(618, null); + } else { + if (unionIndex618 == 1) { + Utf8 charSequence618; + Object oldString618 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(618); + if (oldString618 instanceof Utf8) { + charSequence618 = (decoder).readString(((Utf8) oldString618)); + } else { + charSequence618 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(618, charSequence618); + } else { + throw new RuntimeException(("Illegal union index for 'F618': "+ unionIndex618)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex619 = (decoder.readIndex()); + if (unionIndex619 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(619, null); + } else { + if (unionIndex619 == 1) { + Utf8 charSequence619; + Object oldString619 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(619); + if (oldString619 instanceof Utf8) { + charSequence619 = (decoder).readString(((Utf8) oldString619)); + } else { + charSequence619 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(619, charSequence619); + } else { + throw new RuntimeException(("Illegal union index for 'F619': "+ unionIndex619)); + } + } + int unionIndex620 = (decoder.readIndex()); + if (unionIndex620 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(620, null); + } else { + if (unionIndex620 == 1) { + Utf8 charSequence620; + Object oldString620 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(620); + if (oldString620 instanceof Utf8) { + charSequence620 = (decoder).readString(((Utf8) oldString620)); + } else { + charSequence620 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(620, charSequence620); + } else { + throw new RuntimeException(("Illegal union index for 'F620': "+ unionIndex620)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex621 = (decoder.readIndex()); + if (unionIndex621 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(621, null); + } else { + if (unionIndex621 == 1) { + Utf8 charSequence621; + Object oldString621 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(621); + if (oldString621 instanceof Utf8) { + charSequence621 = (decoder).readString(((Utf8) oldString621)); + } else { + charSequence621 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(621, charSequence621); + } else { + throw new RuntimeException(("Illegal union index for 'F621': "+ unionIndex621)); + } + } + int unionIndex622 = (decoder.readIndex()); + if (unionIndex622 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(622, null); + } else { + if (unionIndex622 == 1) { + Utf8 charSequence622; + Object oldString622 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(622); + if (oldString622 instanceof Utf8) { + charSequence622 = (decoder).readString(((Utf8) oldString622)); + } else { + charSequence622 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(622, charSequence622); + } else { + throw new RuntimeException(("Illegal union index for 'F622': "+ unionIndex622)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex623 = (decoder.readIndex()); + if (unionIndex623 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(623, null); + } else { + if (unionIndex623 == 1) { + Utf8 charSequence623; + Object oldString623 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(623); + if (oldString623 instanceof Utf8) { + charSequence623 = (decoder).readString(((Utf8) oldString623)); + } else { + charSequence623 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(623, charSequence623); + } else { + throw new RuntimeException(("Illegal union index for 'F623': "+ unionIndex623)); + } + } + int unionIndex624 = (decoder.readIndex()); + if (unionIndex624 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(624, null); + } else { + if (unionIndex624 == 1) { + Utf8 charSequence624; + Object oldString624 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(624); + if (oldString624 instanceof Utf8) { + charSequence624 = (decoder).readString(((Utf8) oldString624)); + } else { + charSequence624 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(624, charSequence624); + } else { + throw new RuntimeException(("Illegal union index for 'F624': "+ unionIndex624)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex625 = (decoder.readIndex()); + if (unionIndex625 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(625, null); + } else { + if (unionIndex625 == 1) { + Utf8 charSequence625; + Object oldString625 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(625); + if (oldString625 instanceof Utf8) { + charSequence625 = (decoder).readString(((Utf8) oldString625)); + } else { + charSequence625 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(625, charSequence625); + } else { + throw new RuntimeException(("Illegal union index for 'F625': "+ unionIndex625)); + } + } + int unionIndex626 = (decoder.readIndex()); + if (unionIndex626 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(626, null); + } else { + if (unionIndex626 == 1) { + Utf8 charSequence626; + Object oldString626 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(626); + if (oldString626 instanceof Utf8) { + charSequence626 = (decoder).readString(((Utf8) oldString626)); + } else { + charSequence626 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(626, charSequence626); + } else { + throw new RuntimeException(("Illegal union index for 'F626': "+ unionIndex626)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex627 = (decoder.readIndex()); + if (unionIndex627 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(627, null); + } else { + if (unionIndex627 == 1) { + Utf8 charSequence627; + Object oldString627 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(627); + if (oldString627 instanceof Utf8) { + charSequence627 = (decoder).readString(((Utf8) oldString627)); + } else { + charSequence627 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(627, charSequence627); + } else { + throw new RuntimeException(("Illegal union index for 'F627': "+ unionIndex627)); + } + } + int unionIndex628 = (decoder.readIndex()); + if (unionIndex628 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(628, null); + } else { + if (unionIndex628 == 1) { + Utf8 charSequence628; + Object oldString628 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(628); + if (oldString628 instanceof Utf8) { + charSequence628 = (decoder).readString(((Utf8) oldString628)); + } else { + charSequence628 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(628, charSequence628); + } else { + throw new RuntimeException(("Illegal union index for 'F628': "+ unionIndex628)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex629 = (decoder.readIndex()); + if (unionIndex629 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(629, null); + } else { + if (unionIndex629 == 1) { + Utf8 charSequence629; + Object oldString629 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(629); + if (oldString629 instanceof Utf8) { + charSequence629 = (decoder).readString(((Utf8) oldString629)); + } else { + charSequence629 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(629, charSequence629); + } else { + throw new RuntimeException(("Illegal union index for 'F629': "+ unionIndex629)); + } + } + int unionIndex630 = (decoder.readIndex()); + if (unionIndex630 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(630, null); + } else { + if (unionIndex630 == 1) { + Utf8 charSequence630; + Object oldString630 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(630); + if (oldString630 instanceof Utf8) { + charSequence630 = (decoder).readString(((Utf8) oldString630)); + } else { + charSequence630 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(630, charSequence630); + } else { + throw new RuntimeException(("Illegal union index for 'F630': "+ unionIndex630)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex631 = (decoder.readIndex()); + if (unionIndex631 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(631, null); + } else { + if (unionIndex631 == 1) { + Utf8 charSequence631; + Object oldString631 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(631); + if (oldString631 instanceof Utf8) { + charSequence631 = (decoder).readString(((Utf8) oldString631)); + } else { + charSequence631 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(631, charSequence631); + } else { + throw new RuntimeException(("Illegal union index for 'F631': "+ unionIndex631)); + } + } + int unionIndex632 = (decoder.readIndex()); + if (unionIndex632 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(632, null); + } else { + if (unionIndex632 == 1) { + Utf8 charSequence632; + Object oldString632 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(632); + if (oldString632 instanceof Utf8) { + charSequence632 = (decoder).readString(((Utf8) oldString632)); + } else { + charSequence632 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(632, charSequence632); + } else { + throw new RuntimeException(("Illegal union index for 'F632': "+ unionIndex632)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex633 = (decoder.readIndex()); + if (unionIndex633 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(633, null); + } else { + if (unionIndex633 == 1) { + Utf8 charSequence633; + Object oldString633 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(633); + if (oldString633 instanceof Utf8) { + charSequence633 = (decoder).readString(((Utf8) oldString633)); + } else { + charSequence633 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(633, charSequence633); + } else { + throw new RuntimeException(("Illegal union index for 'F633': "+ unionIndex633)); + } + } + int unionIndex634 = (decoder.readIndex()); + if (unionIndex634 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(634, null); + } else { + if (unionIndex634 == 1) { + Utf8 charSequence634; + Object oldString634 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(634); + if (oldString634 instanceof Utf8) { + charSequence634 = (decoder).readString(((Utf8) oldString634)); + } else { + charSequence634 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(634, charSequence634); + } else { + throw new RuntimeException(("Illegal union index for 'F634': "+ unionIndex634)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex635 = (decoder.readIndex()); + if (unionIndex635 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(635, null); + } else { + if (unionIndex635 == 1) { + Utf8 charSequence635; + Object oldString635 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(635); + if (oldString635 instanceof Utf8) { + charSequence635 = (decoder).readString(((Utf8) oldString635)); + } else { + charSequence635 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(635, charSequence635); + } else { + throw new RuntimeException(("Illegal union index for 'F635': "+ unionIndex635)); + } + } + int unionIndex636 = (decoder.readIndex()); + if (unionIndex636 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(636, null); + } else { + if (unionIndex636 == 1) { + Utf8 charSequence636; + Object oldString636 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(636); + if (oldString636 instanceof Utf8) { + charSequence636 = (decoder).readString(((Utf8) oldString636)); + } else { + charSequence636 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(636, charSequence636); + } else { + throw new RuntimeException(("Illegal union index for 'F636': "+ unionIndex636)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex637 = (decoder.readIndex()); + if (unionIndex637 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(637, null); + } else { + if (unionIndex637 == 1) { + Utf8 charSequence637; + Object oldString637 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(637); + if (oldString637 instanceof Utf8) { + charSequence637 = (decoder).readString(((Utf8) oldString637)); + } else { + charSequence637 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(637, charSequence637); + } else { + throw new RuntimeException(("Illegal union index for 'F637': "+ unionIndex637)); + } + } + int unionIndex638 = (decoder.readIndex()); + if (unionIndex638 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(638, null); + } else { + if (unionIndex638 == 1) { + Utf8 charSequence638; + Object oldString638 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(638); + if (oldString638 instanceof Utf8) { + charSequence638 = (decoder).readString(((Utf8) oldString638)); + } else { + charSequence638 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(638, charSequence638); + } else { + throw new RuntimeException(("Illegal union index for 'F638': "+ unionIndex638)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex639 = (decoder.readIndex()); + if (unionIndex639 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(639, null); + } else { + if (unionIndex639 == 1) { + Utf8 charSequence639; + Object oldString639 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(639); + if (oldString639 instanceof Utf8) { + charSequence639 = (decoder).readString(((Utf8) oldString639)); + } else { + charSequence639 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(639, charSequence639); + } else { + throw new RuntimeException(("Illegal union index for 'F639': "+ unionIndex639)); + } + } + int unionIndex640 = (decoder.readIndex()); + if (unionIndex640 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(640, null); + } else { + if (unionIndex640 == 1) { + Utf8 charSequence640; + Object oldString640 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(640); + if (oldString640 instanceof Utf8) { + charSequence640 = (decoder).readString(((Utf8) oldString640)); + } else { + charSequence640 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(640, charSequence640); + } else { + throw new RuntimeException(("Illegal union index for 'F640': "+ unionIndex640)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex641 = (decoder.readIndex()); + if (unionIndex641 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(641, null); + } else { + if (unionIndex641 == 1) { + Utf8 charSequence641; + Object oldString641 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(641); + if (oldString641 instanceof Utf8) { + charSequence641 = (decoder).readString(((Utf8) oldString641)); + } else { + charSequence641 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(641, charSequence641); + } else { + throw new RuntimeException(("Illegal union index for 'F641': "+ unionIndex641)); + } + } + int unionIndex642 = (decoder.readIndex()); + if (unionIndex642 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(642, null); + } else { + if (unionIndex642 == 1) { + Utf8 charSequence642; + Object oldString642 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(642); + if (oldString642 instanceof Utf8) { + charSequence642 = (decoder).readString(((Utf8) oldString642)); + } else { + charSequence642 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(642, charSequence642); + } else { + throw new RuntimeException(("Illegal union index for 'F642': "+ unionIndex642)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex643 = (decoder.readIndex()); + if (unionIndex643 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(643, null); + } else { + if (unionIndex643 == 1) { + Utf8 charSequence643; + Object oldString643 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(643); + if (oldString643 instanceof Utf8) { + charSequence643 = (decoder).readString(((Utf8) oldString643)); + } else { + charSequence643 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(643, charSequence643); + } else { + throw new RuntimeException(("Illegal union index for 'F643': "+ unionIndex643)); + } + } + int unionIndex644 = (decoder.readIndex()); + if (unionIndex644 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(644, null); + } else { + if (unionIndex644 == 1) { + Utf8 charSequence644; + Object oldString644 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(644); + if (oldString644 instanceof Utf8) { + charSequence644 = (decoder).readString(((Utf8) oldString644)); + } else { + charSequence644 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(644, charSequence644); + } else { + throw new RuntimeException(("Illegal union index for 'F644': "+ unionIndex644)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex645 = (decoder.readIndex()); + if (unionIndex645 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(645, null); + } else { + if (unionIndex645 == 1) { + Utf8 charSequence645; + Object oldString645 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(645); + if (oldString645 instanceof Utf8) { + charSequence645 = (decoder).readString(((Utf8) oldString645)); + } else { + charSequence645 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(645, charSequence645); + } else { + throw new RuntimeException(("Illegal union index for 'F645': "+ unionIndex645)); + } + } + int unionIndex646 = (decoder.readIndex()); + if (unionIndex646 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(646, null); + } else { + if (unionIndex646 == 1) { + Utf8 charSequence646; + Object oldString646 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(646); + if (oldString646 instanceof Utf8) { + charSequence646 = (decoder).readString(((Utf8) oldString646)); + } else { + charSequence646 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(646, charSequence646); + } else { + throw new RuntimeException(("Illegal union index for 'F646': "+ unionIndex646)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex647 = (decoder.readIndex()); + if (unionIndex647 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(647, null); + } else { + if (unionIndex647 == 1) { + Utf8 charSequence647; + Object oldString647 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(647); + if (oldString647 instanceof Utf8) { + charSequence647 = (decoder).readString(((Utf8) oldString647)); + } else { + charSequence647 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(647, charSequence647); + } else { + throw new RuntimeException(("Illegal union index for 'F647': "+ unionIndex647)); + } + } + int unionIndex648 = (decoder.readIndex()); + if (unionIndex648 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(648, null); + } else { + if (unionIndex648 == 1) { + Utf8 charSequence648; + Object oldString648 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(648); + if (oldString648 instanceof Utf8) { + charSequence648 = (decoder).readString(((Utf8) oldString648)); + } else { + charSequence648 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(648, charSequence648); + } else { + throw new RuntimeException(("Illegal union index for 'F648': "+ unionIndex648)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex649 = (decoder.readIndex()); + if (unionIndex649 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(649, null); + } else { + if (unionIndex649 == 1) { + Utf8 charSequence649; + Object oldString649 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(649); + if (oldString649 instanceof Utf8) { + charSequence649 = (decoder).readString(((Utf8) oldString649)); + } else { + charSequence649 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(649, charSequence649); + } else { + throw new RuntimeException(("Illegal union index for 'F649': "+ unionIndex649)); + } + } + int unionIndex650 = (decoder.readIndex()); + if (unionIndex650 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(650, null); + } else { + if (unionIndex650 == 1) { + Utf8 charSequence650; + Object oldString650 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(650); + if (oldString650 instanceof Utf8) { + charSequence650 = (decoder).readString(((Utf8) oldString650)); + } else { + charSequence650 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(650, charSequence650); + } else { + throw new RuntimeException(("Illegal union index for 'F650': "+ unionIndex650)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex651 = (decoder.readIndex()); + if (unionIndex651 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(651, null); + } else { + if (unionIndex651 == 1) { + Utf8 charSequence651; + Object oldString651 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(651); + if (oldString651 instanceof Utf8) { + charSequence651 = (decoder).readString(((Utf8) oldString651)); + } else { + charSequence651 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(651, charSequence651); + } else { + throw new RuntimeException(("Illegal union index for 'F651': "+ unionIndex651)); + } + } + int unionIndex652 = (decoder.readIndex()); + if (unionIndex652 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(652, null); + } else { + if (unionIndex652 == 1) { + Utf8 charSequence652; + Object oldString652 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(652); + if (oldString652 instanceof Utf8) { + charSequence652 = (decoder).readString(((Utf8) oldString652)); + } else { + charSequence652 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(652, charSequence652); + } else { + throw new RuntimeException(("Illegal union index for 'F652': "+ unionIndex652)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex653 = (decoder.readIndex()); + if (unionIndex653 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(653, null); + } else { + if (unionIndex653 == 1) { + Utf8 charSequence653; + Object oldString653 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(653); + if (oldString653 instanceof Utf8) { + charSequence653 = (decoder).readString(((Utf8) oldString653)); + } else { + charSequence653 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(653, charSequence653); + } else { + throw new RuntimeException(("Illegal union index for 'F653': "+ unionIndex653)); + } + } + int unionIndex654 = (decoder.readIndex()); + if (unionIndex654 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(654, null); + } else { + if (unionIndex654 == 1) { + Utf8 charSequence654; + Object oldString654 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(654); + if (oldString654 instanceof Utf8) { + charSequence654 = (decoder).readString(((Utf8) oldString654)); + } else { + charSequence654 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(654, charSequence654); + } else { + throw new RuntimeException(("Illegal union index for 'F654': "+ unionIndex654)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex655 = (decoder.readIndex()); + if (unionIndex655 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(655, null); + } else { + if (unionIndex655 == 1) { + Utf8 charSequence655; + Object oldString655 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(655); + if (oldString655 instanceof Utf8) { + charSequence655 = (decoder).readString(((Utf8) oldString655)); + } else { + charSequence655 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(655, charSequence655); + } else { + throw new RuntimeException(("Illegal union index for 'F655': "+ unionIndex655)); + } + } + int unionIndex656 = (decoder.readIndex()); + if (unionIndex656 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(656, null); + } else { + if (unionIndex656 == 1) { + Utf8 charSequence656; + Object oldString656 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(656); + if (oldString656 instanceof Utf8) { + charSequence656 = (decoder).readString(((Utf8) oldString656)); + } else { + charSequence656 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(656, charSequence656); + } else { + throw new RuntimeException(("Illegal union index for 'F656': "+ unionIndex656)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex657 = (decoder.readIndex()); + if (unionIndex657 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(657, null); + } else { + if (unionIndex657 == 1) { + Utf8 charSequence657; + Object oldString657 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(657); + if (oldString657 instanceof Utf8) { + charSequence657 = (decoder).readString(((Utf8) oldString657)); + } else { + charSequence657 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(657, charSequence657); + } else { + throw new RuntimeException(("Illegal union index for 'F657': "+ unionIndex657)); + } + } + int unionIndex658 = (decoder.readIndex()); + if (unionIndex658 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(658, null); + } else { + if (unionIndex658 == 1) { + Utf8 charSequence658; + Object oldString658 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(658); + if (oldString658 instanceof Utf8) { + charSequence658 = (decoder).readString(((Utf8) oldString658)); + } else { + charSequence658 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(658, charSequence658); + } else { + throw new RuntimeException(("Illegal union index for 'F658': "+ unionIndex658)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex659 = (decoder.readIndex()); + if (unionIndex659 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(659, null); + } else { + if (unionIndex659 == 1) { + Utf8 charSequence659; + Object oldString659 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(659); + if (oldString659 instanceof Utf8) { + charSequence659 = (decoder).readString(((Utf8) oldString659)); + } else { + charSequence659 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(659, charSequence659); + } else { + throw new RuntimeException(("Illegal union index for 'F659': "+ unionIndex659)); + } + } + int unionIndex660 = (decoder.readIndex()); + if (unionIndex660 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(660, null); + } else { + if (unionIndex660 == 1) { + Utf8 charSequence660; + Object oldString660 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(660); + if (oldString660 instanceof Utf8) { + charSequence660 = (decoder).readString(((Utf8) oldString660)); + } else { + charSequence660 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(660, charSequence660); + } else { + throw new RuntimeException(("Illegal union index for 'F660': "+ unionIndex660)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex661 = (decoder.readIndex()); + if (unionIndex661 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(661, null); + } else { + if (unionIndex661 == 1) { + Utf8 charSequence661; + Object oldString661 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(661); + if (oldString661 instanceof Utf8) { + charSequence661 = (decoder).readString(((Utf8) oldString661)); + } else { + charSequence661 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(661, charSequence661); + } else { + throw new RuntimeException(("Illegal union index for 'F661': "+ unionIndex661)); + } + } + int unionIndex662 = (decoder.readIndex()); + if (unionIndex662 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(662, null); + } else { + if (unionIndex662 == 1) { + Utf8 charSequence662; + Object oldString662 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(662); + if (oldString662 instanceof Utf8) { + charSequence662 = (decoder).readString(((Utf8) oldString662)); + } else { + charSequence662 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(662, charSequence662); + } else { + throw new RuntimeException(("Illegal union index for 'F662': "+ unionIndex662)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex663 = (decoder.readIndex()); + if (unionIndex663 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(663, null); + } else { + if (unionIndex663 == 1) { + Utf8 charSequence663; + Object oldString663 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(663); + if (oldString663 instanceof Utf8) { + charSequence663 = (decoder).readString(((Utf8) oldString663)); + } else { + charSequence663 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(663, charSequence663); + } else { + throw new RuntimeException(("Illegal union index for 'F663': "+ unionIndex663)); + } + } + int unionIndex664 = (decoder.readIndex()); + if (unionIndex664 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(664, null); + } else { + if (unionIndex664 == 1) { + Utf8 charSequence664; + Object oldString664 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(664); + if (oldString664 instanceof Utf8) { + charSequence664 = (decoder).readString(((Utf8) oldString664)); + } else { + charSequence664 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(664, charSequence664); + } else { + throw new RuntimeException(("Illegal union index for 'F664': "+ unionIndex664)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex665 = (decoder.readIndex()); + if (unionIndex665 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(665, null); + } else { + if (unionIndex665 == 1) { + Utf8 charSequence665; + Object oldString665 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(665); + if (oldString665 instanceof Utf8) { + charSequence665 = (decoder).readString(((Utf8) oldString665)); + } else { + charSequence665 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(665, charSequence665); + } else { + throw new RuntimeException(("Illegal union index for 'F665': "+ unionIndex665)); + } + } + int unionIndex666 = (decoder.readIndex()); + if (unionIndex666 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(666, null); + } else { + if (unionIndex666 == 1) { + Utf8 charSequence666; + Object oldString666 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(666); + if (oldString666 instanceof Utf8) { + charSequence666 = (decoder).readString(((Utf8) oldString666)); + } else { + charSequence666 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(666, charSequence666); + } else { + throw new RuntimeException(("Illegal union index for 'F666': "+ unionIndex666)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex667 = (decoder.readIndex()); + if (unionIndex667 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(667, null); + } else { + if (unionIndex667 == 1) { + Utf8 charSequence667; + Object oldString667 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(667); + if (oldString667 instanceof Utf8) { + charSequence667 = (decoder).readString(((Utf8) oldString667)); + } else { + charSequence667 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(667, charSequence667); + } else { + throw new RuntimeException(("Illegal union index for 'F667': "+ unionIndex667)); + } + } + int unionIndex668 = (decoder.readIndex()); + if (unionIndex668 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(668, null); + } else { + if (unionIndex668 == 1) { + Utf8 charSequence668; + Object oldString668 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(668); + if (oldString668 instanceof Utf8) { + charSequence668 = (decoder).readString(((Utf8) oldString668)); + } else { + charSequence668 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(668, charSequence668); + } else { + throw new RuntimeException(("Illegal union index for 'F668': "+ unionIndex668)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex669 = (decoder.readIndex()); + if (unionIndex669 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(669, null); + } else { + if (unionIndex669 == 1) { + Utf8 charSequence669; + Object oldString669 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(669); + if (oldString669 instanceof Utf8) { + charSequence669 = (decoder).readString(((Utf8) oldString669)); + } else { + charSequence669 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(669, charSequence669); + } else { + throw new RuntimeException(("Illegal union index for 'F669': "+ unionIndex669)); + } + } + int unionIndex670 = (decoder.readIndex()); + if (unionIndex670 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(670, null); + } else { + if (unionIndex670 == 1) { + Utf8 charSequence670; + Object oldString670 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(670); + if (oldString670 instanceof Utf8) { + charSequence670 = (decoder).readString(((Utf8) oldString670)); + } else { + charSequence670 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(670, charSequence670); + } else { + throw new RuntimeException(("Illegal union index for 'F670': "+ unionIndex670)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex671 = (decoder.readIndex()); + if (unionIndex671 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(671, null); + } else { + if (unionIndex671 == 1) { + Utf8 charSequence671; + Object oldString671 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(671); + if (oldString671 instanceof Utf8) { + charSequence671 = (decoder).readString(((Utf8) oldString671)); + } else { + charSequence671 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(671, charSequence671); + } else { + throw new RuntimeException(("Illegal union index for 'F671': "+ unionIndex671)); + } + } + int unionIndex672 = (decoder.readIndex()); + if (unionIndex672 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(672, null); + } else { + if (unionIndex672 == 1) { + Utf8 charSequence672; + Object oldString672 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(672); + if (oldString672 instanceof Utf8) { + charSequence672 = (decoder).readString(((Utf8) oldString672)); + } else { + charSequence672 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(672, charSequence672); + } else { + throw new RuntimeException(("Illegal union index for 'F672': "+ unionIndex672)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex673 = (decoder.readIndex()); + if (unionIndex673 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(673, null); + } else { + if (unionIndex673 == 1) { + Utf8 charSequence673; + Object oldString673 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(673); + if (oldString673 instanceof Utf8) { + charSequence673 = (decoder).readString(((Utf8) oldString673)); + } else { + charSequence673 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(673, charSequence673); + } else { + throw new RuntimeException(("Illegal union index for 'F673': "+ unionIndex673)); + } + } + int unionIndex674 = (decoder.readIndex()); + if (unionIndex674 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(674, null); + } else { + if (unionIndex674 == 1) { + Utf8 charSequence674; + Object oldString674 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(674); + if (oldString674 instanceof Utf8) { + charSequence674 = (decoder).readString(((Utf8) oldString674)); + } else { + charSequence674 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(674, charSequence674); + } else { + throw new RuntimeException(("Illegal union index for 'F674': "+ unionIndex674)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex675 = (decoder.readIndex()); + if (unionIndex675 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(675, null); + } else { + if (unionIndex675 == 1) { + Utf8 charSequence675; + Object oldString675 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(675); + if (oldString675 instanceof Utf8) { + charSequence675 = (decoder).readString(((Utf8) oldString675)); + } else { + charSequence675 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(675, charSequence675); + } else { + throw new RuntimeException(("Illegal union index for 'F675': "+ unionIndex675)); + } + } + int unionIndex676 = (decoder.readIndex()); + if (unionIndex676 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(676, null); + } else { + if (unionIndex676 == 1) { + Utf8 charSequence676; + Object oldString676 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(676); + if (oldString676 instanceof Utf8) { + charSequence676 = (decoder).readString(((Utf8) oldString676)); + } else { + charSequence676 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(676, charSequence676); + } else { + throw new RuntimeException(("Illegal union index for 'F676': "+ unionIndex676)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex677 = (decoder.readIndex()); + if (unionIndex677 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(677, null); + } else { + if (unionIndex677 == 1) { + Utf8 charSequence677; + Object oldString677 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(677); + if (oldString677 instanceof Utf8) { + charSequence677 = (decoder).readString(((Utf8) oldString677)); + } else { + charSequence677 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(677, charSequence677); + } else { + throw new RuntimeException(("Illegal union index for 'F677': "+ unionIndex677)); + } + } + int unionIndex678 = (decoder.readIndex()); + if (unionIndex678 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(678, null); + } else { + if (unionIndex678 == 1) { + Utf8 charSequence678; + Object oldString678 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(678); + if (oldString678 instanceof Utf8) { + charSequence678 = (decoder).readString(((Utf8) oldString678)); + } else { + charSequence678 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(678, charSequence678); + } else { + throw new RuntimeException(("Illegal union index for 'F678': "+ unionIndex678)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex679 = (decoder.readIndex()); + if (unionIndex679 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(679, null); + } else { + if (unionIndex679 == 1) { + Utf8 charSequence679; + Object oldString679 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(679); + if (oldString679 instanceof Utf8) { + charSequence679 = (decoder).readString(((Utf8) oldString679)); + } else { + charSequence679 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(679, charSequence679); + } else { + throw new RuntimeException(("Illegal union index for 'F679': "+ unionIndex679)); + } + } + int unionIndex680 = (decoder.readIndex()); + if (unionIndex680 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(680, null); + } else { + if (unionIndex680 == 1) { + Utf8 charSequence680; + Object oldString680 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(680); + if (oldString680 instanceof Utf8) { + charSequence680 = (decoder).readString(((Utf8) oldString680)); + } else { + charSequence680 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(680, charSequence680); + } else { + throw new RuntimeException(("Illegal union index for 'F680': "+ unionIndex680)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex681 = (decoder.readIndex()); + if (unionIndex681 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(681, null); + } else { + if (unionIndex681 == 1) { + Utf8 charSequence681; + Object oldString681 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(681); + if (oldString681 instanceof Utf8) { + charSequence681 = (decoder).readString(((Utf8) oldString681)); + } else { + charSequence681 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(681, charSequence681); + } else { + throw new RuntimeException(("Illegal union index for 'F681': "+ unionIndex681)); + } + } + int unionIndex682 = (decoder.readIndex()); + if (unionIndex682 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(682, null); + } else { + if (unionIndex682 == 1) { + Utf8 charSequence682; + Object oldString682 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(682); + if (oldString682 instanceof Utf8) { + charSequence682 = (decoder).readString(((Utf8) oldString682)); + } else { + charSequence682 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(682, charSequence682); + } else { + throw new RuntimeException(("Illegal union index for 'F682': "+ unionIndex682)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex683 = (decoder.readIndex()); + if (unionIndex683 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(683, null); + } else { + if (unionIndex683 == 1) { + Utf8 charSequence683; + Object oldString683 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(683); + if (oldString683 instanceof Utf8) { + charSequence683 = (decoder).readString(((Utf8) oldString683)); + } else { + charSequence683 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(683, charSequence683); + } else { + throw new RuntimeException(("Illegal union index for 'F683': "+ unionIndex683)); + } + } + int unionIndex684 = (decoder.readIndex()); + if (unionIndex684 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(684, null); + } else { + if (unionIndex684 == 1) { + Utf8 charSequence684; + Object oldString684 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(684); + if (oldString684 instanceof Utf8) { + charSequence684 = (decoder).readString(((Utf8) oldString684)); + } else { + charSequence684 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(684, charSequence684); + } else { + throw new RuntimeException(("Illegal union index for 'F684': "+ unionIndex684)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex685 = (decoder.readIndex()); + if (unionIndex685 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(685, null); + } else { + if (unionIndex685 == 1) { + Utf8 charSequence685; + Object oldString685 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(685); + if (oldString685 instanceof Utf8) { + charSequence685 = (decoder).readString(((Utf8) oldString685)); + } else { + charSequence685 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(685, charSequence685); + } else { + throw new RuntimeException(("Illegal union index for 'F685': "+ unionIndex685)); + } + } + int unionIndex686 = (decoder.readIndex()); + if (unionIndex686 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(686, null); + } else { + if (unionIndex686 == 1) { + Utf8 charSequence686; + Object oldString686 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(686); + if (oldString686 instanceof Utf8) { + charSequence686 = (decoder).readString(((Utf8) oldString686)); + } else { + charSequence686 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(686, charSequence686); + } else { + throw new RuntimeException(("Illegal union index for 'F686': "+ unionIndex686)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex687 = (decoder.readIndex()); + if (unionIndex687 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(687, null); + } else { + if (unionIndex687 == 1) { + Utf8 charSequence687; + Object oldString687 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(687); + if (oldString687 instanceof Utf8) { + charSequence687 = (decoder).readString(((Utf8) oldString687)); + } else { + charSequence687 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(687, charSequence687); + } else { + throw new RuntimeException(("Illegal union index for 'F687': "+ unionIndex687)); + } + } + int unionIndex688 = (decoder.readIndex()); + if (unionIndex688 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(688, null); + } else { + if (unionIndex688 == 1) { + Utf8 charSequence688; + Object oldString688 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(688); + if (oldString688 instanceof Utf8) { + charSequence688 = (decoder).readString(((Utf8) oldString688)); + } else { + charSequence688 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(688, charSequence688); + } else { + throw new RuntimeException(("Illegal union index for 'F688': "+ unionIndex688)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex689 = (decoder.readIndex()); + if (unionIndex689 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(689, null); + } else { + if (unionIndex689 == 1) { + Utf8 charSequence689; + Object oldString689 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(689); + if (oldString689 instanceof Utf8) { + charSequence689 = (decoder).readString(((Utf8) oldString689)); + } else { + charSequence689 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(689, charSequence689); + } else { + throw new RuntimeException(("Illegal union index for 'F689': "+ unionIndex689)); + } + } + int unionIndex690 = (decoder.readIndex()); + if (unionIndex690 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(690, null); + } else { + if (unionIndex690 == 1) { + Utf8 charSequence690; + Object oldString690 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(690); + if (oldString690 instanceof Utf8) { + charSequence690 = (decoder).readString(((Utf8) oldString690)); + } else { + charSequence690 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(690, charSequence690); + } else { + throw new RuntimeException(("Illegal union index for 'F690': "+ unionIndex690)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex691 = (decoder.readIndex()); + if (unionIndex691 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(691, null); + } else { + if (unionIndex691 == 1) { + Utf8 charSequence691; + Object oldString691 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(691); + if (oldString691 instanceof Utf8) { + charSequence691 = (decoder).readString(((Utf8) oldString691)); + } else { + charSequence691 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(691, charSequence691); + } else { + throw new RuntimeException(("Illegal union index for 'F691': "+ unionIndex691)); + } + } + int unionIndex692 = (decoder.readIndex()); + if (unionIndex692 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(692, null); + } else { + if (unionIndex692 == 1) { + Utf8 charSequence692; + Object oldString692 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(692); + if (oldString692 instanceof Utf8) { + charSequence692 = (decoder).readString(((Utf8) oldString692)); + } else { + charSequence692 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(692, charSequence692); + } else { + throw new RuntimeException(("Illegal union index for 'F692': "+ unionIndex692)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex693 = (decoder.readIndex()); + if (unionIndex693 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(693, null); + } else { + if (unionIndex693 == 1) { + Utf8 charSequence693; + Object oldString693 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(693); + if (oldString693 instanceof Utf8) { + charSequence693 = (decoder).readString(((Utf8) oldString693)); + } else { + charSequence693 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(693, charSequence693); + } else { + throw new RuntimeException(("Illegal union index for 'F693': "+ unionIndex693)); + } + } + int unionIndex694 = (decoder.readIndex()); + if (unionIndex694 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(694, null); + } else { + if (unionIndex694 == 1) { + Utf8 charSequence694; + Object oldString694 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(694); + if (oldString694 instanceof Utf8) { + charSequence694 = (decoder).readString(((Utf8) oldString694)); + } else { + charSequence694 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(694, charSequence694); + } else { + throw new RuntimeException(("Illegal union index for 'F694': "+ unionIndex694)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex695 = (decoder.readIndex()); + if (unionIndex695 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(695, null); + } else { + if (unionIndex695 == 1) { + Utf8 charSequence695; + Object oldString695 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(695); + if (oldString695 instanceof Utf8) { + charSequence695 = (decoder).readString(((Utf8) oldString695)); + } else { + charSequence695 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(695, charSequence695); + } else { + throw new RuntimeException(("Illegal union index for 'F695': "+ unionIndex695)); + } + } + int unionIndex696 = (decoder.readIndex()); + if (unionIndex696 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(696, null); + } else { + if (unionIndex696 == 1) { + Utf8 charSequence696; + Object oldString696 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(696); + if (oldString696 instanceof Utf8) { + charSequence696 = (decoder).readString(((Utf8) oldString696)); + } else { + charSequence696 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(696, charSequence696); + } else { + throw new RuntimeException(("Illegal union index for 'F696': "+ unionIndex696)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex697 = (decoder.readIndex()); + if (unionIndex697 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(697, null); + } else { + if (unionIndex697 == 1) { + Utf8 charSequence697; + Object oldString697 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(697); + if (oldString697 instanceof Utf8) { + charSequence697 = (decoder).readString(((Utf8) oldString697)); + } else { + charSequence697 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(697, charSequence697); + } else { + throw new RuntimeException(("Illegal union index for 'F697': "+ unionIndex697)); + } + } + int unionIndex698 = (decoder.readIndex()); + if (unionIndex698 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(698, null); + } else { + if (unionIndex698 == 1) { + Utf8 charSequence698; + Object oldString698 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(698); + if (oldString698 instanceof Utf8) { + charSequence698 = (decoder).readString(((Utf8) oldString698)); + } else { + charSequence698 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(698, charSequence698); + } else { + throw new RuntimeException(("Illegal union index for 'F698': "+ unionIndex698)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex699 = (decoder.readIndex()); + if (unionIndex699 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(699, null); + } else { + if (unionIndex699 == 1) { + Utf8 charSequence699; + Object oldString699 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(699); + if (oldString699 instanceof Utf8) { + charSequence699 = (decoder).readString(((Utf8) oldString699)); + } else { + charSequence699 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(699, charSequence699); + } else { + throw new RuntimeException(("Illegal union index for 'F699': "+ unionIndex699)); + } + } + int unionIndex700 = (decoder.readIndex()); + if (unionIndex700 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(700, null); + } else { + if (unionIndex700 == 1) { + Utf8 charSequence700; + Object oldString700 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(700); + if (oldString700 instanceof Utf8) { + charSequence700 = (decoder).readString(((Utf8) oldString700)); + } else { + charSequence700 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(700, charSequence700); + } else { + throw new RuntimeException(("Illegal union index for 'F700': "+ unionIndex700)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex701 = (decoder.readIndex()); + if (unionIndex701 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(701, null); + } else { + if (unionIndex701 == 1) { + Utf8 charSequence701; + Object oldString701 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(701); + if (oldString701 instanceof Utf8) { + charSequence701 = (decoder).readString(((Utf8) oldString701)); + } else { + charSequence701 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(701, charSequence701); + } else { + throw new RuntimeException(("Illegal union index for 'F701': "+ unionIndex701)); + } + } + int unionIndex702 = (decoder.readIndex()); + if (unionIndex702 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(702, null); + } else { + if (unionIndex702 == 1) { + Utf8 charSequence702; + Object oldString702 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(702); + if (oldString702 instanceof Utf8) { + charSequence702 = (decoder).readString(((Utf8) oldString702)); + } else { + charSequence702 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(702, charSequence702); + } else { + throw new RuntimeException(("Illegal union index for 'F702': "+ unionIndex702)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex703 = (decoder.readIndex()); + if (unionIndex703 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(703, null); + } else { + if (unionIndex703 == 1) { + Utf8 charSequence703; + Object oldString703 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(703); + if (oldString703 instanceof Utf8) { + charSequence703 = (decoder).readString(((Utf8) oldString703)); + } else { + charSequence703 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(703, charSequence703); + } else { + throw new RuntimeException(("Illegal union index for 'F703': "+ unionIndex703)); + } + } + int unionIndex704 = (decoder.readIndex()); + if (unionIndex704 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(704, null); + } else { + if (unionIndex704 == 1) { + Utf8 charSequence704; + Object oldString704 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(704); + if (oldString704 instanceof Utf8) { + charSequence704 = (decoder).readString(((Utf8) oldString704)); + } else { + charSequence704 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(704, charSequence704); + } else { + throw new RuntimeException(("Illegal union index for 'F704': "+ unionIndex704)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex705 = (decoder.readIndex()); + if (unionIndex705 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(705, null); + } else { + if (unionIndex705 == 1) { + Utf8 charSequence705; + Object oldString705 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(705); + if (oldString705 instanceof Utf8) { + charSequence705 = (decoder).readString(((Utf8) oldString705)); + } else { + charSequence705 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(705, charSequence705); + } else { + throw new RuntimeException(("Illegal union index for 'F705': "+ unionIndex705)); + } + } + int unionIndex706 = (decoder.readIndex()); + if (unionIndex706 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(706, null); + } else { + if (unionIndex706 == 1) { + Utf8 charSequence706; + Object oldString706 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(706); + if (oldString706 instanceof Utf8) { + charSequence706 = (decoder).readString(((Utf8) oldString706)); + } else { + charSequence706 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(706, charSequence706); + } else { + throw new RuntimeException(("Illegal union index for 'F706': "+ unionIndex706)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex707 = (decoder.readIndex()); + if (unionIndex707 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(707, null); + } else { + if (unionIndex707 == 1) { + Utf8 charSequence707; + Object oldString707 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(707); + if (oldString707 instanceof Utf8) { + charSequence707 = (decoder).readString(((Utf8) oldString707)); + } else { + charSequence707 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(707, charSequence707); + } else { + throw new RuntimeException(("Illegal union index for 'F707': "+ unionIndex707)); + } + } + int unionIndex708 = (decoder.readIndex()); + if (unionIndex708 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(708, null); + } else { + if (unionIndex708 == 1) { + Utf8 charSequence708; + Object oldString708 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(708); + if (oldString708 instanceof Utf8) { + charSequence708 = (decoder).readString(((Utf8) oldString708)); + } else { + charSequence708 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(708, charSequence708); + } else { + throw new RuntimeException(("Illegal union index for 'F708': "+ unionIndex708)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex709 = (decoder.readIndex()); + if (unionIndex709 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(709, null); + } else { + if (unionIndex709 == 1) { + Utf8 charSequence709; + Object oldString709 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(709); + if (oldString709 instanceof Utf8) { + charSequence709 = (decoder).readString(((Utf8) oldString709)); + } else { + charSequence709 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(709, charSequence709); + } else { + throw new RuntimeException(("Illegal union index for 'F709': "+ unionIndex709)); + } + } + int unionIndex710 = (decoder.readIndex()); + if (unionIndex710 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(710, null); + } else { + if (unionIndex710 == 1) { + Utf8 charSequence710; + Object oldString710 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(710); + if (oldString710 instanceof Utf8) { + charSequence710 = (decoder).readString(((Utf8) oldString710)); + } else { + charSequence710 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(710, charSequence710); + } else { + throw new RuntimeException(("Illegal union index for 'F710': "+ unionIndex710)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex711 = (decoder.readIndex()); + if (unionIndex711 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(711, null); + } else { + if (unionIndex711 == 1) { + Utf8 charSequence711; + Object oldString711 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(711); + if (oldString711 instanceof Utf8) { + charSequence711 = (decoder).readString(((Utf8) oldString711)); + } else { + charSequence711 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(711, charSequence711); + } else { + throw new RuntimeException(("Illegal union index for 'F711': "+ unionIndex711)); + } + } + int unionIndex712 = (decoder.readIndex()); + if (unionIndex712 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(712, null); + } else { + if (unionIndex712 == 1) { + Utf8 charSequence712; + Object oldString712 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(712); + if (oldString712 instanceof Utf8) { + charSequence712 = (decoder).readString(((Utf8) oldString712)); + } else { + charSequence712 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(712, charSequence712); + } else { + throw new RuntimeException(("Illegal union index for 'F712': "+ unionIndex712)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex713 = (decoder.readIndex()); + if (unionIndex713 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(713, null); + } else { + if (unionIndex713 == 1) { + Utf8 charSequence713; + Object oldString713 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(713); + if (oldString713 instanceof Utf8) { + charSequence713 = (decoder).readString(((Utf8) oldString713)); + } else { + charSequence713 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(713, charSequence713); + } else { + throw new RuntimeException(("Illegal union index for 'F713': "+ unionIndex713)); + } + } + int unionIndex714 = (decoder.readIndex()); + if (unionIndex714 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(714, null); + } else { + if (unionIndex714 == 1) { + Utf8 charSequence714; + Object oldString714 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(714); + if (oldString714 instanceof Utf8) { + charSequence714 = (decoder).readString(((Utf8) oldString714)); + } else { + charSequence714 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(714, charSequence714); + } else { + throw new RuntimeException(("Illegal union index for 'F714': "+ unionIndex714)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex715 = (decoder.readIndex()); + if (unionIndex715 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(715, null); + } else { + if (unionIndex715 == 1) { + Utf8 charSequence715; + Object oldString715 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(715); + if (oldString715 instanceof Utf8) { + charSequence715 = (decoder).readString(((Utf8) oldString715)); + } else { + charSequence715 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(715, charSequence715); + } else { + throw new RuntimeException(("Illegal union index for 'F715': "+ unionIndex715)); + } + } + int unionIndex716 = (decoder.readIndex()); + if (unionIndex716 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(716, null); + } else { + if (unionIndex716 == 1) { + Utf8 charSequence716; + Object oldString716 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(716); + if (oldString716 instanceof Utf8) { + charSequence716 = (decoder).readString(((Utf8) oldString716)); + } else { + charSequence716 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(716, charSequence716); + } else { + throw new RuntimeException(("Illegal union index for 'F716': "+ unionIndex716)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex717 = (decoder.readIndex()); + if (unionIndex717 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(717, null); + } else { + if (unionIndex717 == 1) { + Utf8 charSequence717; + Object oldString717 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(717); + if (oldString717 instanceof Utf8) { + charSequence717 = (decoder).readString(((Utf8) oldString717)); + } else { + charSequence717 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(717, charSequence717); + } else { + throw new RuntimeException(("Illegal union index for 'F717': "+ unionIndex717)); + } + } + int unionIndex718 = (decoder.readIndex()); + if (unionIndex718 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(718, null); + } else { + if (unionIndex718 == 1) { + Utf8 charSequence718; + Object oldString718 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(718); + if (oldString718 instanceof Utf8) { + charSequence718 = (decoder).readString(((Utf8) oldString718)); + } else { + charSequence718 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(718, charSequence718); + } else { + throw new RuntimeException(("Illegal union index for 'F718': "+ unionIndex718)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex719 = (decoder.readIndex()); + if (unionIndex719 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(719, null); + } else { + if (unionIndex719 == 1) { + Utf8 charSequence719; + Object oldString719 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(719); + if (oldString719 instanceof Utf8) { + charSequence719 = (decoder).readString(((Utf8) oldString719)); + } else { + charSequence719 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(719, charSequence719); + } else { + throw new RuntimeException(("Illegal union index for 'F719': "+ unionIndex719)); + } + } + int unionIndex720 = (decoder.readIndex()); + if (unionIndex720 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(720, null); + } else { + if (unionIndex720 == 1) { + Utf8 charSequence720; + Object oldString720 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(720); + if (oldString720 instanceof Utf8) { + charSequence720 = (decoder).readString(((Utf8) oldString720)); + } else { + charSequence720 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(720, charSequence720); + } else { + throw new RuntimeException(("Illegal union index for 'F720': "+ unionIndex720)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex721 = (decoder.readIndex()); + if (unionIndex721 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(721, null); + } else { + if (unionIndex721 == 1) { + Utf8 charSequence721; + Object oldString721 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(721); + if (oldString721 instanceof Utf8) { + charSequence721 = (decoder).readString(((Utf8) oldString721)); + } else { + charSequence721 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(721, charSequence721); + } else { + throw new RuntimeException(("Illegal union index for 'F721': "+ unionIndex721)); + } + } + int unionIndex722 = (decoder.readIndex()); + if (unionIndex722 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(722, null); + } else { + if (unionIndex722 == 1) { + Utf8 charSequence722; + Object oldString722 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(722); + if (oldString722 instanceof Utf8) { + charSequence722 = (decoder).readString(((Utf8) oldString722)); + } else { + charSequence722 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(722, charSequence722); + } else { + throw new RuntimeException(("Illegal union index for 'F722': "+ unionIndex722)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex723 = (decoder.readIndex()); + if (unionIndex723 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(723, null); + } else { + if (unionIndex723 == 1) { + Utf8 charSequence723; + Object oldString723 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(723); + if (oldString723 instanceof Utf8) { + charSequence723 = (decoder).readString(((Utf8) oldString723)); + } else { + charSequence723 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(723, charSequence723); + } else { + throw new RuntimeException(("Illegal union index for 'F723': "+ unionIndex723)); + } + } + int unionIndex724 = (decoder.readIndex()); + if (unionIndex724 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(724, null); + } else { + if (unionIndex724 == 1) { + Utf8 charSequence724; + Object oldString724 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(724); + if (oldString724 instanceof Utf8) { + charSequence724 = (decoder).readString(((Utf8) oldString724)); + } else { + charSequence724 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(724, charSequence724); + } else { + throw new RuntimeException(("Illegal union index for 'F724': "+ unionIndex724)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex725 = (decoder.readIndex()); + if (unionIndex725 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(725, null); + } else { + if (unionIndex725 == 1) { + Utf8 charSequence725; + Object oldString725 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(725); + if (oldString725 instanceof Utf8) { + charSequence725 = (decoder).readString(((Utf8) oldString725)); + } else { + charSequence725 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(725, charSequence725); + } else { + throw new RuntimeException(("Illegal union index for 'F725': "+ unionIndex725)); + } + } + int unionIndex726 = (decoder.readIndex()); + if (unionIndex726 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(726, null); + } else { + if (unionIndex726 == 1) { + Utf8 charSequence726; + Object oldString726 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(726); + if (oldString726 instanceof Utf8) { + charSequence726 = (decoder).readString(((Utf8) oldString726)); + } else { + charSequence726 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(726, charSequence726); + } else { + throw new RuntimeException(("Illegal union index for 'F726': "+ unionIndex726)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex727 = (decoder.readIndex()); + if (unionIndex727 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(727, null); + } else { + if (unionIndex727 == 1) { + Utf8 charSequence727; + Object oldString727 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(727); + if (oldString727 instanceof Utf8) { + charSequence727 = (decoder).readString(((Utf8) oldString727)); + } else { + charSequence727 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(727, charSequence727); + } else { + throw new RuntimeException(("Illegal union index for 'F727': "+ unionIndex727)); + } + } + int unionIndex728 = (decoder.readIndex()); + if (unionIndex728 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(728, null); + } else { + if (unionIndex728 == 1) { + Utf8 charSequence728; + Object oldString728 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(728); + if (oldString728 instanceof Utf8) { + charSequence728 = (decoder).readString(((Utf8) oldString728)); + } else { + charSequence728 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(728, charSequence728); + } else { + throw new RuntimeException(("Illegal union index for 'F728': "+ unionIndex728)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex729 = (decoder.readIndex()); + if (unionIndex729 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(729, null); + } else { + if (unionIndex729 == 1) { + Utf8 charSequence729; + Object oldString729 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(729); + if (oldString729 instanceof Utf8) { + charSequence729 = (decoder).readString(((Utf8) oldString729)); + } else { + charSequence729 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(729, charSequence729); + } else { + throw new RuntimeException(("Illegal union index for 'F729': "+ unionIndex729)); + } + } + int unionIndex730 = (decoder.readIndex()); + if (unionIndex730 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(730, null); + } else { + if (unionIndex730 == 1) { + Utf8 charSequence730; + Object oldString730 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(730); + if (oldString730 instanceof Utf8) { + charSequence730 = (decoder).readString(((Utf8) oldString730)); + } else { + charSequence730 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(730, charSequence730); + } else { + throw new RuntimeException(("Illegal union index for 'F730': "+ unionIndex730)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex731 = (decoder.readIndex()); + if (unionIndex731 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(731, null); + } else { + if (unionIndex731 == 1) { + Utf8 charSequence731; + Object oldString731 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(731); + if (oldString731 instanceof Utf8) { + charSequence731 = (decoder).readString(((Utf8) oldString731)); + } else { + charSequence731 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(731, charSequence731); + } else { + throw new RuntimeException(("Illegal union index for 'F731': "+ unionIndex731)); + } + } + int unionIndex732 = (decoder.readIndex()); + if (unionIndex732 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(732, null); + } else { + if (unionIndex732 == 1) { + Utf8 charSequence732; + Object oldString732 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(732); + if (oldString732 instanceof Utf8) { + charSequence732 = (decoder).readString(((Utf8) oldString732)); + } else { + charSequence732 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(732, charSequence732); + } else { + throw new RuntimeException(("Illegal union index for 'F732': "+ unionIndex732)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex733 = (decoder.readIndex()); + if (unionIndex733 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(733, null); + } else { + if (unionIndex733 == 1) { + Utf8 charSequence733; + Object oldString733 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(733); + if (oldString733 instanceof Utf8) { + charSequence733 = (decoder).readString(((Utf8) oldString733)); + } else { + charSequence733 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(733, charSequence733); + } else { + throw new RuntimeException(("Illegal union index for 'F733': "+ unionIndex733)); + } + } + int unionIndex734 = (decoder.readIndex()); + if (unionIndex734 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(734, null); + } else { + if (unionIndex734 == 1) { + Utf8 charSequence734; + Object oldString734 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(734); + if (oldString734 instanceof Utf8) { + charSequence734 = (decoder).readString(((Utf8) oldString734)); + } else { + charSequence734 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(734, charSequence734); + } else { + throw new RuntimeException(("Illegal union index for 'F734': "+ unionIndex734)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex735 = (decoder.readIndex()); + if (unionIndex735 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(735, null); + } else { + if (unionIndex735 == 1) { + Utf8 charSequence735; + Object oldString735 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(735); + if (oldString735 instanceof Utf8) { + charSequence735 = (decoder).readString(((Utf8) oldString735)); + } else { + charSequence735 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(735, charSequence735); + } else { + throw new RuntimeException(("Illegal union index for 'F735': "+ unionIndex735)); + } + } + int unionIndex736 = (decoder.readIndex()); + if (unionIndex736 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(736, null); + } else { + if (unionIndex736 == 1) { + Utf8 charSequence736; + Object oldString736 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(736); + if (oldString736 instanceof Utf8) { + charSequence736 = (decoder).readString(((Utf8) oldString736)); + } else { + charSequence736 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(736, charSequence736); + } else { + throw new RuntimeException(("Illegal union index for 'F736': "+ unionIndex736)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex737 = (decoder.readIndex()); + if (unionIndex737 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(737, null); + } else { + if (unionIndex737 == 1) { + Utf8 charSequence737; + Object oldString737 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(737); + if (oldString737 instanceof Utf8) { + charSequence737 = (decoder).readString(((Utf8) oldString737)); + } else { + charSequence737 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(737, charSequence737); + } else { + throw new RuntimeException(("Illegal union index for 'F737': "+ unionIndex737)); + } + } + int unionIndex738 = (decoder.readIndex()); + if (unionIndex738 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(738, null); + } else { + if (unionIndex738 == 1) { + Utf8 charSequence738; + Object oldString738 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(738); + if (oldString738 instanceof Utf8) { + charSequence738 = (decoder).readString(((Utf8) oldString738)); + } else { + charSequence738 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(738, charSequence738); + } else { + throw new RuntimeException(("Illegal union index for 'F738': "+ unionIndex738)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex739 = (decoder.readIndex()); + if (unionIndex739 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(739, null); + } else { + if (unionIndex739 == 1) { + Utf8 charSequence739; + Object oldString739 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(739); + if (oldString739 instanceof Utf8) { + charSequence739 = (decoder).readString(((Utf8) oldString739)); + } else { + charSequence739 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(739, charSequence739); + } else { + throw new RuntimeException(("Illegal union index for 'F739': "+ unionIndex739)); + } + } + int unionIndex740 = (decoder.readIndex()); + if (unionIndex740 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(740, null); + } else { + if (unionIndex740 == 1) { + Utf8 charSequence740; + Object oldString740 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(740); + if (oldString740 instanceof Utf8) { + charSequence740 = (decoder).readString(((Utf8) oldString740)); + } else { + charSequence740 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(740, charSequence740); + } else { + throw new RuntimeException(("Illegal union index for 'F740': "+ unionIndex740)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex741 = (decoder.readIndex()); + if (unionIndex741 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(741, null); + } else { + if (unionIndex741 == 1) { + Utf8 charSequence741; + Object oldString741 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(741); + if (oldString741 instanceof Utf8) { + charSequence741 = (decoder).readString(((Utf8) oldString741)); + } else { + charSequence741 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(741, charSequence741); + } else { + throw new RuntimeException(("Illegal union index for 'F741': "+ unionIndex741)); + } + } + int unionIndex742 = (decoder.readIndex()); + if (unionIndex742 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(742, null); + } else { + if (unionIndex742 == 1) { + Utf8 charSequence742; + Object oldString742 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(742); + if (oldString742 instanceof Utf8) { + charSequence742 = (decoder).readString(((Utf8) oldString742)); + } else { + charSequence742 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(742, charSequence742); + } else { + throw new RuntimeException(("Illegal union index for 'F742': "+ unionIndex742)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex743 = (decoder.readIndex()); + if (unionIndex743 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(743, null); + } else { + if (unionIndex743 == 1) { + Utf8 charSequence743; + Object oldString743 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(743); + if (oldString743 instanceof Utf8) { + charSequence743 = (decoder).readString(((Utf8) oldString743)); + } else { + charSequence743 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(743, charSequence743); + } else { + throw new RuntimeException(("Illegal union index for 'F743': "+ unionIndex743)); + } + } + int unionIndex744 = (decoder.readIndex()); + if (unionIndex744 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(744, null); + } else { + if (unionIndex744 == 1) { + Utf8 charSequence744; + Object oldString744 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(744); + if (oldString744 instanceof Utf8) { + charSequence744 = (decoder).readString(((Utf8) oldString744)); + } else { + charSequence744 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(744, charSequence744); + } else { + throw new RuntimeException(("Illegal union index for 'F744': "+ unionIndex744)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex745 = (decoder.readIndex()); + if (unionIndex745 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(745, null); + } else { + if (unionIndex745 == 1) { + Utf8 charSequence745; + Object oldString745 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(745); + if (oldString745 instanceof Utf8) { + charSequence745 = (decoder).readString(((Utf8) oldString745)); + } else { + charSequence745 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(745, charSequence745); + } else { + throw new RuntimeException(("Illegal union index for 'F745': "+ unionIndex745)); + } + } + int unionIndex746 = (decoder.readIndex()); + if (unionIndex746 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(746, null); + } else { + if (unionIndex746 == 1) { + Utf8 charSequence746; + Object oldString746 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(746); + if (oldString746 instanceof Utf8) { + charSequence746 = (decoder).readString(((Utf8) oldString746)); + } else { + charSequence746 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(746, charSequence746); + } else { + throw new RuntimeException(("Illegal union index for 'F746': "+ unionIndex746)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex747 = (decoder.readIndex()); + if (unionIndex747 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(747, null); + } else { + if (unionIndex747 == 1) { + Utf8 charSequence747; + Object oldString747 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(747); + if (oldString747 instanceof Utf8) { + charSequence747 = (decoder).readString(((Utf8) oldString747)); + } else { + charSequence747 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(747, charSequence747); + } else { + throw new RuntimeException(("Illegal union index for 'F747': "+ unionIndex747)); + } + } + int unionIndex748 = (decoder.readIndex()); + if (unionIndex748 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(748, null); + } else { + if (unionIndex748 == 1) { + Utf8 charSequence748; + Object oldString748 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(748); + if (oldString748 instanceof Utf8) { + charSequence748 = (decoder).readString(((Utf8) oldString748)); + } else { + charSequence748 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(748, charSequence748); + } else { + throw new RuntimeException(("Illegal union index for 'F748': "+ unionIndex748)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex749 = (decoder.readIndex()); + if (unionIndex749 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(749, null); + } else { + if (unionIndex749 == 1) { + Utf8 charSequence749; + Object oldString749 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(749); + if (oldString749 instanceof Utf8) { + charSequence749 = (decoder).readString(((Utf8) oldString749)); + } else { + charSequence749 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(749, charSequence749); + } else { + throw new RuntimeException(("Illegal union index for 'F749': "+ unionIndex749)); + } + } + int unionIndex750 = (decoder.readIndex()); + if (unionIndex750 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(750, null); + } else { + if (unionIndex750 == 1) { + Utf8 charSequence750; + Object oldString750 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(750); + if (oldString750 instanceof Utf8) { + charSequence750 = (decoder).readString(((Utf8) oldString750)); + } else { + charSequence750 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(750, charSequence750); + } else { + throw new RuntimeException(("Illegal union index for 'F750': "+ unionIndex750)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex751 = (decoder.readIndex()); + if (unionIndex751 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(751, null); + } else { + if (unionIndex751 == 1) { + Utf8 charSequence751; + Object oldString751 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(751); + if (oldString751 instanceof Utf8) { + charSequence751 = (decoder).readString(((Utf8) oldString751)); + } else { + charSequence751 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(751, charSequence751); + } else { + throw new RuntimeException(("Illegal union index for 'F751': "+ unionIndex751)); + } + } + int unionIndex752 = (decoder.readIndex()); + if (unionIndex752 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(752, null); + } else { + if (unionIndex752 == 1) { + Utf8 charSequence752; + Object oldString752 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(752); + if (oldString752 instanceof Utf8) { + charSequence752 = (decoder).readString(((Utf8) oldString752)); + } else { + charSequence752 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(752, charSequence752); + } else { + throw new RuntimeException(("Illegal union index for 'F752': "+ unionIndex752)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex753 = (decoder.readIndex()); + if (unionIndex753 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(753, null); + } else { + if (unionIndex753 == 1) { + Utf8 charSequence753; + Object oldString753 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(753); + if (oldString753 instanceof Utf8) { + charSequence753 = (decoder).readString(((Utf8) oldString753)); + } else { + charSequence753 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(753, charSequence753); + } else { + throw new RuntimeException(("Illegal union index for 'F753': "+ unionIndex753)); + } + } + int unionIndex754 = (decoder.readIndex()); + if (unionIndex754 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(754, null); + } else { + if (unionIndex754 == 1) { + Utf8 charSequence754; + Object oldString754 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(754); + if (oldString754 instanceof Utf8) { + charSequence754 = (decoder).readString(((Utf8) oldString754)); + } else { + charSequence754 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(754, charSequence754); + } else { + throw new RuntimeException(("Illegal union index for 'F754': "+ unionIndex754)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex755 = (decoder.readIndex()); + if (unionIndex755 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(755, null); + } else { + if (unionIndex755 == 1) { + Utf8 charSequence755; + Object oldString755 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(755); + if (oldString755 instanceof Utf8) { + charSequence755 = (decoder).readString(((Utf8) oldString755)); + } else { + charSequence755 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(755, charSequence755); + } else { + throw new RuntimeException(("Illegal union index for 'F755': "+ unionIndex755)); + } + } + int unionIndex756 = (decoder.readIndex()); + if (unionIndex756 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(756, null); + } else { + if (unionIndex756 == 1) { + Utf8 charSequence756; + Object oldString756 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(756); + if (oldString756 instanceof Utf8) { + charSequence756 = (decoder).readString(((Utf8) oldString756)); + } else { + charSequence756 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(756, charSequence756); + } else { + throw new RuntimeException(("Illegal union index for 'F756': "+ unionIndex756)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex757 = (decoder.readIndex()); + if (unionIndex757 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(757, null); + } else { + if (unionIndex757 == 1) { + Utf8 charSequence757; + Object oldString757 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(757); + if (oldString757 instanceof Utf8) { + charSequence757 = (decoder).readString(((Utf8) oldString757)); + } else { + charSequence757 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(757, charSequence757); + } else { + throw new RuntimeException(("Illegal union index for 'F757': "+ unionIndex757)); + } + } + int unionIndex758 = (decoder.readIndex()); + if (unionIndex758 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(758, null); + } else { + if (unionIndex758 == 1) { + Utf8 charSequence758; + Object oldString758 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(758); + if (oldString758 instanceof Utf8) { + charSequence758 = (decoder).readString(((Utf8) oldString758)); + } else { + charSequence758 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(758, charSequence758); + } else { + throw new RuntimeException(("Illegal union index for 'F758': "+ unionIndex758)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex759 = (decoder.readIndex()); + if (unionIndex759 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(759, null); + } else { + if (unionIndex759 == 1) { + Utf8 charSequence759; + Object oldString759 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(759); + if (oldString759 instanceof Utf8) { + charSequence759 = (decoder).readString(((Utf8) oldString759)); + } else { + charSequence759 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(759, charSequence759); + } else { + throw new RuntimeException(("Illegal union index for 'F759': "+ unionIndex759)); + } + } + int unionIndex760 = (decoder.readIndex()); + if (unionIndex760 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(760, null); + } else { + if (unionIndex760 == 1) { + Utf8 charSequence760; + Object oldString760 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(760); + if (oldString760 instanceof Utf8) { + charSequence760 = (decoder).readString(((Utf8) oldString760)); + } else { + charSequence760 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(760, charSequence760); + } else { + throw new RuntimeException(("Illegal union index for 'F760': "+ unionIndex760)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex761 = (decoder.readIndex()); + if (unionIndex761 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(761, null); + } else { + if (unionIndex761 == 1) { + Utf8 charSequence761; + Object oldString761 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(761); + if (oldString761 instanceof Utf8) { + charSequence761 = (decoder).readString(((Utf8) oldString761)); + } else { + charSequence761 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(761, charSequence761); + } else { + throw new RuntimeException(("Illegal union index for 'F761': "+ unionIndex761)); + } + } + int unionIndex762 = (decoder.readIndex()); + if (unionIndex762 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(762, null); + } else { + if (unionIndex762 == 1) { + Utf8 charSequence762; + Object oldString762 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(762); + if (oldString762 instanceof Utf8) { + charSequence762 = (decoder).readString(((Utf8) oldString762)); + } else { + charSequence762 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(762, charSequence762); + } else { + throw new RuntimeException(("Illegal union index for 'F762': "+ unionIndex762)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex763 = (decoder.readIndex()); + if (unionIndex763 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(763, null); + } else { + if (unionIndex763 == 1) { + Utf8 charSequence763; + Object oldString763 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(763); + if (oldString763 instanceof Utf8) { + charSequence763 = (decoder).readString(((Utf8) oldString763)); + } else { + charSequence763 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(763, charSequence763); + } else { + throw new RuntimeException(("Illegal union index for 'F763': "+ unionIndex763)); + } + } + int unionIndex764 = (decoder.readIndex()); + if (unionIndex764 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(764, null); + } else { + if (unionIndex764 == 1) { + Utf8 charSequence764; + Object oldString764 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(764); + if (oldString764 instanceof Utf8) { + charSequence764 = (decoder).readString(((Utf8) oldString764)); + } else { + charSequence764 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(764, charSequence764); + } else { + throw new RuntimeException(("Illegal union index for 'F764': "+ unionIndex764)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex765 = (decoder.readIndex()); + if (unionIndex765 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(765, null); + } else { + if (unionIndex765 == 1) { + Utf8 charSequence765; + Object oldString765 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(765); + if (oldString765 instanceof Utf8) { + charSequence765 = (decoder).readString(((Utf8) oldString765)); + } else { + charSequence765 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(765, charSequence765); + } else { + throw new RuntimeException(("Illegal union index for 'F765': "+ unionIndex765)); + } + } + int unionIndex766 = (decoder.readIndex()); + if (unionIndex766 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(766, null); + } else { + if (unionIndex766 == 1) { + Utf8 charSequence766; + Object oldString766 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(766); + if (oldString766 instanceof Utf8) { + charSequence766 = (decoder).readString(((Utf8) oldString766)); + } else { + charSequence766 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(766, charSequence766); + } else { + throw new RuntimeException(("Illegal union index for 'F766': "+ unionIndex766)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex767 = (decoder.readIndex()); + if (unionIndex767 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(767, null); + } else { + if (unionIndex767 == 1) { + Utf8 charSequence767; + Object oldString767 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(767); + if (oldString767 instanceof Utf8) { + charSequence767 = (decoder).readString(((Utf8) oldString767)); + } else { + charSequence767 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(767, charSequence767); + } else { + throw new RuntimeException(("Illegal union index for 'F767': "+ unionIndex767)); + } + } + int unionIndex768 = (decoder.readIndex()); + if (unionIndex768 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(768, null); + } else { + if (unionIndex768 == 1) { + Utf8 charSequence768; + Object oldString768 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(768); + if (oldString768 instanceof Utf8) { + charSequence768 = (decoder).readString(((Utf8) oldString768)); + } else { + charSequence768 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(768, charSequence768); + } else { + throw new RuntimeException(("Illegal union index for 'F768': "+ unionIndex768)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex769 = (decoder.readIndex()); + if (unionIndex769 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(769, null); + } else { + if (unionIndex769 == 1) { + Utf8 charSequence769; + Object oldString769 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(769); + if (oldString769 instanceof Utf8) { + charSequence769 = (decoder).readString(((Utf8) oldString769)); + } else { + charSequence769 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(769, charSequence769); + } else { + throw new RuntimeException(("Illegal union index for 'F769': "+ unionIndex769)); + } + } + int unionIndex770 = (decoder.readIndex()); + if (unionIndex770 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(770, null); + } else { + if (unionIndex770 == 1) { + Utf8 charSequence770; + Object oldString770 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(770); + if (oldString770 instanceof Utf8) { + charSequence770 = (decoder).readString(((Utf8) oldString770)); + } else { + charSequence770 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(770, charSequence770); + } else { + throw new RuntimeException(("Illegal union index for 'F770': "+ unionIndex770)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex771 = (decoder.readIndex()); + if (unionIndex771 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(771, null); + } else { + if (unionIndex771 == 1) { + Utf8 charSequence771; + Object oldString771 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(771); + if (oldString771 instanceof Utf8) { + charSequence771 = (decoder).readString(((Utf8) oldString771)); + } else { + charSequence771 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(771, charSequence771); + } else { + throw new RuntimeException(("Illegal union index for 'F771': "+ unionIndex771)); + } + } + int unionIndex772 = (decoder.readIndex()); + if (unionIndex772 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(772, null); + } else { + if (unionIndex772 == 1) { + Utf8 charSequence772; + Object oldString772 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(772); + if (oldString772 instanceof Utf8) { + charSequence772 = (decoder).readString(((Utf8) oldString772)); + } else { + charSequence772 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(772, charSequence772); + } else { + throw new RuntimeException(("Illegal union index for 'F772': "+ unionIndex772)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex773 = (decoder.readIndex()); + if (unionIndex773 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(773, null); + } else { + if (unionIndex773 == 1) { + Utf8 charSequence773; + Object oldString773 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(773); + if (oldString773 instanceof Utf8) { + charSequence773 = (decoder).readString(((Utf8) oldString773)); + } else { + charSequence773 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(773, charSequence773); + } else { + throw new RuntimeException(("Illegal union index for 'F773': "+ unionIndex773)); + } + } + int unionIndex774 = (decoder.readIndex()); + if (unionIndex774 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(774, null); + } else { + if (unionIndex774 == 1) { + Utf8 charSequence774; + Object oldString774 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(774); + if (oldString774 instanceof Utf8) { + charSequence774 = (decoder).readString(((Utf8) oldString774)); + } else { + charSequence774 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(774, charSequence774); + } else { + throw new RuntimeException(("Illegal union index for 'F774': "+ unionIndex774)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex775 = (decoder.readIndex()); + if (unionIndex775 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(775, null); + } else { + if (unionIndex775 == 1) { + Utf8 charSequence775; + Object oldString775 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(775); + if (oldString775 instanceof Utf8) { + charSequence775 = (decoder).readString(((Utf8) oldString775)); + } else { + charSequence775 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(775, charSequence775); + } else { + throw new RuntimeException(("Illegal union index for 'F775': "+ unionIndex775)); + } + } + int unionIndex776 = (decoder.readIndex()); + if (unionIndex776 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(776, null); + } else { + if (unionIndex776 == 1) { + Utf8 charSequence776; + Object oldString776 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(776); + if (oldString776 instanceof Utf8) { + charSequence776 = (decoder).readString(((Utf8) oldString776)); + } else { + charSequence776 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(776, charSequence776); + } else { + throw new RuntimeException(("Illegal union index for 'F776': "+ unionIndex776)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex777 = (decoder.readIndex()); + if (unionIndex777 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(777, null); + } else { + if (unionIndex777 == 1) { + Utf8 charSequence777; + Object oldString777 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(777); + if (oldString777 instanceof Utf8) { + charSequence777 = (decoder).readString(((Utf8) oldString777)); + } else { + charSequence777 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(777, charSequence777); + } else { + throw new RuntimeException(("Illegal union index for 'F777': "+ unionIndex777)); + } + } + int unionIndex778 = (decoder.readIndex()); + if (unionIndex778 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(778, null); + } else { + if (unionIndex778 == 1) { + Utf8 charSequence778; + Object oldString778 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(778); + if (oldString778 instanceof Utf8) { + charSequence778 = (decoder).readString(((Utf8) oldString778)); + } else { + charSequence778 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(778, charSequence778); + } else { + throw new RuntimeException(("Illegal union index for 'F778': "+ unionIndex778)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex779 = (decoder.readIndex()); + if (unionIndex779 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(779, null); + } else { + if (unionIndex779 == 1) { + Utf8 charSequence779; + Object oldString779 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(779); + if (oldString779 instanceof Utf8) { + charSequence779 = (decoder).readString(((Utf8) oldString779)); + } else { + charSequence779 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(779, charSequence779); + } else { + throw new RuntimeException(("Illegal union index for 'F779': "+ unionIndex779)); + } + } + int unionIndex780 = (decoder.readIndex()); + if (unionIndex780 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(780, null); + } else { + if (unionIndex780 == 1) { + Utf8 charSequence780; + Object oldString780 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(780); + if (oldString780 instanceof Utf8) { + charSequence780 = (decoder).readString(((Utf8) oldString780)); + } else { + charSequence780 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(780, charSequence780); + } else { + throw new RuntimeException(("Illegal union index for 'F780': "+ unionIndex780)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex781 = (decoder.readIndex()); + if (unionIndex781 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(781, null); + } else { + if (unionIndex781 == 1) { + Utf8 charSequence781; + Object oldString781 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(781); + if (oldString781 instanceof Utf8) { + charSequence781 = (decoder).readString(((Utf8) oldString781)); + } else { + charSequence781 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(781, charSequence781); + } else { + throw new RuntimeException(("Illegal union index for 'F781': "+ unionIndex781)); + } + } + int unionIndex782 = (decoder.readIndex()); + if (unionIndex782 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(782, null); + } else { + if (unionIndex782 == 1) { + Utf8 charSequence782; + Object oldString782 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(782); + if (oldString782 instanceof Utf8) { + charSequence782 = (decoder).readString(((Utf8) oldString782)); + } else { + charSequence782 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(782, charSequence782); + } else { + throw new RuntimeException(("Illegal union index for 'F782': "+ unionIndex782)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex783 = (decoder.readIndex()); + if (unionIndex783 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(783, null); + } else { + if (unionIndex783 == 1) { + Utf8 charSequence783; + Object oldString783 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(783); + if (oldString783 instanceof Utf8) { + charSequence783 = (decoder).readString(((Utf8) oldString783)); + } else { + charSequence783 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(783, charSequence783); + } else { + throw new RuntimeException(("Illegal union index for 'F783': "+ unionIndex783)); + } + } + int unionIndex784 = (decoder.readIndex()); + if (unionIndex784 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(784, null); + } else { + if (unionIndex784 == 1) { + Utf8 charSequence784; + Object oldString784 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(784); + if (oldString784 instanceof Utf8) { + charSequence784 = (decoder).readString(((Utf8) oldString784)); + } else { + charSequence784 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(784, charSequence784); + } else { + throw new RuntimeException(("Illegal union index for 'F784': "+ unionIndex784)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex785 = (decoder.readIndex()); + if (unionIndex785 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(785, null); + } else { + if (unionIndex785 == 1) { + Utf8 charSequence785; + Object oldString785 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(785); + if (oldString785 instanceof Utf8) { + charSequence785 = (decoder).readString(((Utf8) oldString785)); + } else { + charSequence785 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(785, charSequence785); + } else { + throw new RuntimeException(("Illegal union index for 'F785': "+ unionIndex785)); + } + } + int unionIndex786 = (decoder.readIndex()); + if (unionIndex786 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(786, null); + } else { + if (unionIndex786 == 1) { + Utf8 charSequence786; + Object oldString786 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(786); + if (oldString786 instanceof Utf8) { + charSequence786 = (decoder).readString(((Utf8) oldString786)); + } else { + charSequence786 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(786, charSequence786); + } else { + throw new RuntimeException(("Illegal union index for 'F786': "+ unionIndex786)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex787 = (decoder.readIndex()); + if (unionIndex787 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(787, null); + } else { + if (unionIndex787 == 1) { + Utf8 charSequence787; + Object oldString787 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(787); + if (oldString787 instanceof Utf8) { + charSequence787 = (decoder).readString(((Utf8) oldString787)); + } else { + charSequence787 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(787, charSequence787); + } else { + throw new RuntimeException(("Illegal union index for 'F787': "+ unionIndex787)); + } + } + int unionIndex788 = (decoder.readIndex()); + if (unionIndex788 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(788, null); + } else { + if (unionIndex788 == 1) { + Utf8 charSequence788; + Object oldString788 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(788); + if (oldString788 instanceof Utf8) { + charSequence788 = (decoder).readString(((Utf8) oldString788)); + } else { + charSequence788 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(788, charSequence788); + } else { + throw new RuntimeException(("Illegal union index for 'F788': "+ unionIndex788)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex789 = (decoder.readIndex()); + if (unionIndex789 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(789, null); + } else { + if (unionIndex789 == 1) { + Utf8 charSequence789; + Object oldString789 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(789); + if (oldString789 instanceof Utf8) { + charSequence789 = (decoder).readString(((Utf8) oldString789)); + } else { + charSequence789 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(789, charSequence789); + } else { + throw new RuntimeException(("Illegal union index for 'F789': "+ unionIndex789)); + } + } + int unionIndex790 = (decoder.readIndex()); + if (unionIndex790 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(790, null); + } else { + if (unionIndex790 == 1) { + Utf8 charSequence790; + Object oldString790 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(790); + if (oldString790 instanceof Utf8) { + charSequence790 = (decoder).readString(((Utf8) oldString790)); + } else { + charSequence790 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(790, charSequence790); + } else { + throw new RuntimeException(("Illegal union index for 'F790': "+ unionIndex790)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex791 = (decoder.readIndex()); + if (unionIndex791 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(791, null); + } else { + if (unionIndex791 == 1) { + Utf8 charSequence791; + Object oldString791 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(791); + if (oldString791 instanceof Utf8) { + charSequence791 = (decoder).readString(((Utf8) oldString791)); + } else { + charSequence791 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(791, charSequence791); + } else { + throw new RuntimeException(("Illegal union index for 'F791': "+ unionIndex791)); + } + } + int unionIndex792 = (decoder.readIndex()); + if (unionIndex792 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(792, null); + } else { + if (unionIndex792 == 1) { + Utf8 charSequence792; + Object oldString792 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(792); + if (oldString792 instanceof Utf8) { + charSequence792 = (decoder).readString(((Utf8) oldString792)); + } else { + charSequence792 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(792, charSequence792); + } else { + throw new RuntimeException(("Illegal union index for 'F792': "+ unionIndex792)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex793 = (decoder.readIndex()); + if (unionIndex793 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(793, null); + } else { + if (unionIndex793 == 1) { + Utf8 charSequence793; + Object oldString793 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(793); + if (oldString793 instanceof Utf8) { + charSequence793 = (decoder).readString(((Utf8) oldString793)); + } else { + charSequence793 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(793, charSequence793); + } else { + throw new RuntimeException(("Illegal union index for 'F793': "+ unionIndex793)); + } + } + int unionIndex794 = (decoder.readIndex()); + if (unionIndex794 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(794, null); + } else { + if (unionIndex794 == 1) { + Utf8 charSequence794; + Object oldString794 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(794); + if (oldString794 instanceof Utf8) { + charSequence794 = (decoder).readString(((Utf8) oldString794)); + } else { + charSequence794 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(794, charSequence794); + } else { + throw new RuntimeException(("Illegal union index for 'F794': "+ unionIndex794)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex795 = (decoder.readIndex()); + if (unionIndex795 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(795, null); + } else { + if (unionIndex795 == 1) { + Utf8 charSequence795; + Object oldString795 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(795); + if (oldString795 instanceof Utf8) { + charSequence795 = (decoder).readString(((Utf8) oldString795)); + } else { + charSequence795 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(795, charSequence795); + } else { + throw new RuntimeException(("Illegal union index for 'F795': "+ unionIndex795)); + } + } + int unionIndex796 = (decoder.readIndex()); + if (unionIndex796 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(796, null); + } else { + if (unionIndex796 == 1) { + Utf8 charSequence796; + Object oldString796 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(796); + if (oldString796 instanceof Utf8) { + charSequence796 = (decoder).readString(((Utf8) oldString796)); + } else { + charSequence796 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(796, charSequence796); + } else { + throw new RuntimeException(("Illegal union index for 'F796': "+ unionIndex796)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex797 = (decoder.readIndex()); + if (unionIndex797 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(797, null); + } else { + if (unionIndex797 == 1) { + Utf8 charSequence797; + Object oldString797 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(797); + if (oldString797 instanceof Utf8) { + charSequence797 = (decoder).readString(((Utf8) oldString797)); + } else { + charSequence797 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(797, charSequence797); + } else { + throw new RuntimeException(("Illegal union index for 'F797': "+ unionIndex797)); + } + } + int unionIndex798 = (decoder.readIndex()); + if (unionIndex798 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(798, null); + } else { + if (unionIndex798 == 1) { + Utf8 charSequence798; + Object oldString798 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(798); + if (oldString798 instanceof Utf8) { + charSequence798 = (decoder).readString(((Utf8) oldString798)); + } else { + charSequence798 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(798, charSequence798); + } else { + throw new RuntimeException(("Illegal union index for 'F798': "+ unionIndex798)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex799 = (decoder.readIndex()); + if (unionIndex799 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(799, null); + } else { + if (unionIndex799 == 1) { + Utf8 charSequence799; + Object oldString799 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(799); + if (oldString799 instanceof Utf8) { + charSequence799 = (decoder).readString(((Utf8) oldString799)); + } else { + charSequence799 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(799, charSequence799); + } else { + throw new RuntimeException(("Illegal union index for 'F799': "+ unionIndex799)); + } + } + int unionIndex800 = (decoder.readIndex()); + if (unionIndex800 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(800, null); + } else { + if (unionIndex800 == 1) { + Utf8 charSequence800; + Object oldString800 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(800); + if (oldString800 instanceof Utf8) { + charSequence800 = (decoder).readString(((Utf8) oldString800)); + } else { + charSequence800 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(800, charSequence800); + } else { + throw new RuntimeException(("Illegal union index for 'F800': "+ unionIndex800)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex801 = (decoder.readIndex()); + if (unionIndex801 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(801, null); + } else { + if (unionIndex801 == 1) { + Utf8 charSequence801; + Object oldString801 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(801); + if (oldString801 instanceof Utf8) { + charSequence801 = (decoder).readString(((Utf8) oldString801)); + } else { + charSequence801 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(801, charSequence801); + } else { + throw new RuntimeException(("Illegal union index for 'F801': "+ unionIndex801)); + } + } + int unionIndex802 = (decoder.readIndex()); + if (unionIndex802 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(802, null); + } else { + if (unionIndex802 == 1) { + Utf8 charSequence802; + Object oldString802 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(802); + if (oldString802 instanceof Utf8) { + charSequence802 = (decoder).readString(((Utf8) oldString802)); + } else { + charSequence802 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(802, charSequence802); + } else { + throw new RuntimeException(("Illegal union index for 'F802': "+ unionIndex802)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex803 = (decoder.readIndex()); + if (unionIndex803 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(803, null); + } else { + if (unionIndex803 == 1) { + Utf8 charSequence803; + Object oldString803 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(803); + if (oldString803 instanceof Utf8) { + charSequence803 = (decoder).readString(((Utf8) oldString803)); + } else { + charSequence803 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(803, charSequence803); + } else { + throw new RuntimeException(("Illegal union index for 'F803': "+ unionIndex803)); + } + } + int unionIndex804 = (decoder.readIndex()); + if (unionIndex804 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(804, null); + } else { + if (unionIndex804 == 1) { + Utf8 charSequence804; + Object oldString804 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(804); + if (oldString804 instanceof Utf8) { + charSequence804 = (decoder).readString(((Utf8) oldString804)); + } else { + charSequence804 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(804, charSequence804); + } else { + throw new RuntimeException(("Illegal union index for 'F804': "+ unionIndex804)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex805 = (decoder.readIndex()); + if (unionIndex805 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(805, null); + } else { + if (unionIndex805 == 1) { + Utf8 charSequence805; + Object oldString805 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(805); + if (oldString805 instanceof Utf8) { + charSequence805 = (decoder).readString(((Utf8) oldString805)); + } else { + charSequence805 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(805, charSequence805); + } else { + throw new RuntimeException(("Illegal union index for 'F805': "+ unionIndex805)); + } + } + int unionIndex806 = (decoder.readIndex()); + if (unionIndex806 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(806, null); + } else { + if (unionIndex806 == 1) { + Utf8 charSequence806; + Object oldString806 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(806); + if (oldString806 instanceof Utf8) { + charSequence806 = (decoder).readString(((Utf8) oldString806)); + } else { + charSequence806 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(806, charSequence806); + } else { + throw new RuntimeException(("Illegal union index for 'F806': "+ unionIndex806)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex807 = (decoder.readIndex()); + if (unionIndex807 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(807, null); + } else { + if (unionIndex807 == 1) { + Utf8 charSequence807; + Object oldString807 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(807); + if (oldString807 instanceof Utf8) { + charSequence807 = (decoder).readString(((Utf8) oldString807)); + } else { + charSequence807 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(807, charSequence807); + } else { + throw new RuntimeException(("Illegal union index for 'F807': "+ unionIndex807)); + } + } + int unionIndex808 = (decoder.readIndex()); + if (unionIndex808 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(808, null); + } else { + if (unionIndex808 == 1) { + Utf8 charSequence808; + Object oldString808 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(808); + if (oldString808 instanceof Utf8) { + charSequence808 = (decoder).readString(((Utf8) oldString808)); + } else { + charSequence808 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(808, charSequence808); + } else { + throw new RuntimeException(("Illegal union index for 'F808': "+ unionIndex808)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex809 = (decoder.readIndex()); + if (unionIndex809 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(809, null); + } else { + if (unionIndex809 == 1) { + Utf8 charSequence809; + Object oldString809 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(809); + if (oldString809 instanceof Utf8) { + charSequence809 = (decoder).readString(((Utf8) oldString809)); + } else { + charSequence809 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(809, charSequence809); + } else { + throw new RuntimeException(("Illegal union index for 'F809': "+ unionIndex809)); + } + } + int unionIndex810 = (decoder.readIndex()); + if (unionIndex810 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(810, null); + } else { + if (unionIndex810 == 1) { + Utf8 charSequence810; + Object oldString810 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(810); + if (oldString810 instanceof Utf8) { + charSequence810 = (decoder).readString(((Utf8) oldString810)); + } else { + charSequence810 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(810, charSequence810); + } else { + throw new RuntimeException(("Illegal union index for 'F810': "+ unionIndex810)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex811 = (decoder.readIndex()); + if (unionIndex811 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(811, null); + } else { + if (unionIndex811 == 1) { + Utf8 charSequence811; + Object oldString811 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(811); + if (oldString811 instanceof Utf8) { + charSequence811 = (decoder).readString(((Utf8) oldString811)); + } else { + charSequence811 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(811, charSequence811); + } else { + throw new RuntimeException(("Illegal union index for 'F811': "+ unionIndex811)); + } + } + int unionIndex812 = (decoder.readIndex()); + if (unionIndex812 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(812, null); + } else { + if (unionIndex812 == 1) { + Utf8 charSequence812; + Object oldString812 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(812); + if (oldString812 instanceof Utf8) { + charSequence812 = (decoder).readString(((Utf8) oldString812)); + } else { + charSequence812 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(812, charSequence812); + } else { + throw new RuntimeException(("Illegal union index for 'F812': "+ unionIndex812)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex813 = (decoder.readIndex()); + if (unionIndex813 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(813, null); + } else { + if (unionIndex813 == 1) { + Utf8 charSequence813; + Object oldString813 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(813); + if (oldString813 instanceof Utf8) { + charSequence813 = (decoder).readString(((Utf8) oldString813)); + } else { + charSequence813 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(813, charSequence813); + } else { + throw new RuntimeException(("Illegal union index for 'F813': "+ unionIndex813)); + } + } + int unionIndex814 = (decoder.readIndex()); + if (unionIndex814 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(814, null); + } else { + if (unionIndex814 == 1) { + Utf8 charSequence814; + Object oldString814 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(814); + if (oldString814 instanceof Utf8) { + charSequence814 = (decoder).readString(((Utf8) oldString814)); + } else { + charSequence814 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(814, charSequence814); + } else { + throw new RuntimeException(("Illegal union index for 'F814': "+ unionIndex814)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex815 = (decoder.readIndex()); + if (unionIndex815 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(815, null); + } else { + if (unionIndex815 == 1) { + Utf8 charSequence815; + Object oldString815 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(815); + if (oldString815 instanceof Utf8) { + charSequence815 = (decoder).readString(((Utf8) oldString815)); + } else { + charSequence815 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(815, charSequence815); + } else { + throw new RuntimeException(("Illegal union index for 'F815': "+ unionIndex815)); + } + } + int unionIndex816 = (decoder.readIndex()); + if (unionIndex816 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(816, null); + } else { + if (unionIndex816 == 1) { + Utf8 charSequence816; + Object oldString816 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(816); + if (oldString816 instanceof Utf8) { + charSequence816 = (decoder).readString(((Utf8) oldString816)); + } else { + charSequence816 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(816, charSequence816); + } else { + throw new RuntimeException(("Illegal union index for 'F816': "+ unionIndex816)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex817 = (decoder.readIndex()); + if (unionIndex817 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(817, null); + } else { + if (unionIndex817 == 1) { + Utf8 charSequence817; + Object oldString817 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(817); + if (oldString817 instanceof Utf8) { + charSequence817 = (decoder).readString(((Utf8) oldString817)); + } else { + charSequence817 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(817, charSequence817); + } else { + throw new RuntimeException(("Illegal union index for 'F817': "+ unionIndex817)); + } + } + int unionIndex818 = (decoder.readIndex()); + if (unionIndex818 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(818, null); + } else { + if (unionIndex818 == 1) { + Utf8 charSequence818; + Object oldString818 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(818); + if (oldString818 instanceof Utf8) { + charSequence818 = (decoder).readString(((Utf8) oldString818)); + } else { + charSequence818 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(818, charSequence818); + } else { + throw new RuntimeException(("Illegal union index for 'F818': "+ unionIndex818)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex819 = (decoder.readIndex()); + if (unionIndex819 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(819, null); + } else { + if (unionIndex819 == 1) { + Utf8 charSequence819; + Object oldString819 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(819); + if (oldString819 instanceof Utf8) { + charSequence819 = (decoder).readString(((Utf8) oldString819)); + } else { + charSequence819 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(819, charSequence819); + } else { + throw new RuntimeException(("Illegal union index for 'F819': "+ unionIndex819)); + } + } + int unionIndex820 = (decoder.readIndex()); + if (unionIndex820 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(820, null); + } else { + if (unionIndex820 == 1) { + Utf8 charSequence820; + Object oldString820 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(820); + if (oldString820 instanceof Utf8) { + charSequence820 = (decoder).readString(((Utf8) oldString820)); + } else { + charSequence820 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(820, charSequence820); + } else { + throw new RuntimeException(("Illegal union index for 'F820': "+ unionIndex820)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex821 = (decoder.readIndex()); + if (unionIndex821 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(821, null); + } else { + if (unionIndex821 == 1) { + Utf8 charSequence821; + Object oldString821 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(821); + if (oldString821 instanceof Utf8) { + charSequence821 = (decoder).readString(((Utf8) oldString821)); + } else { + charSequence821 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(821, charSequence821); + } else { + throw new RuntimeException(("Illegal union index for 'F821': "+ unionIndex821)); + } + } + int unionIndex822 = (decoder.readIndex()); + if (unionIndex822 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(822, null); + } else { + if (unionIndex822 == 1) { + Utf8 charSequence822; + Object oldString822 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(822); + if (oldString822 instanceof Utf8) { + charSequence822 = (decoder).readString(((Utf8) oldString822)); + } else { + charSequence822 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(822, charSequence822); + } else { + throw new RuntimeException(("Illegal union index for 'F822': "+ unionIndex822)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex823 = (decoder.readIndex()); + if (unionIndex823 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(823, null); + } else { + if (unionIndex823 == 1) { + Utf8 charSequence823; + Object oldString823 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(823); + if (oldString823 instanceof Utf8) { + charSequence823 = (decoder).readString(((Utf8) oldString823)); + } else { + charSequence823 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(823, charSequence823); + } else { + throw new RuntimeException(("Illegal union index for 'F823': "+ unionIndex823)); + } + } + int unionIndex824 = (decoder.readIndex()); + if (unionIndex824 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(824, null); + } else { + if (unionIndex824 == 1) { + Utf8 charSequence824; + Object oldString824 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(824); + if (oldString824 instanceof Utf8) { + charSequence824 = (decoder).readString(((Utf8) oldString824)); + } else { + charSequence824 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(824, charSequence824); + } else { + throw new RuntimeException(("Illegal union index for 'F824': "+ unionIndex824)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex825 = (decoder.readIndex()); + if (unionIndex825 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(825, null); + } else { + if (unionIndex825 == 1) { + Utf8 charSequence825; + Object oldString825 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(825); + if (oldString825 instanceof Utf8) { + charSequence825 = (decoder).readString(((Utf8) oldString825)); + } else { + charSequence825 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(825, charSequence825); + } else { + throw new RuntimeException(("Illegal union index for 'F825': "+ unionIndex825)); + } + } + int unionIndex826 = (decoder.readIndex()); + if (unionIndex826 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(826, null); + } else { + if (unionIndex826 == 1) { + Utf8 charSequence826; + Object oldString826 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(826); + if (oldString826 instanceof Utf8) { + charSequence826 = (decoder).readString(((Utf8) oldString826)); + } else { + charSequence826 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(826, charSequence826); + } else { + throw new RuntimeException(("Illegal union index for 'F826': "+ unionIndex826)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex827 = (decoder.readIndex()); + if (unionIndex827 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(827, null); + } else { + if (unionIndex827 == 1) { + Utf8 charSequence827; + Object oldString827 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(827); + if (oldString827 instanceof Utf8) { + charSequence827 = (decoder).readString(((Utf8) oldString827)); + } else { + charSequence827 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(827, charSequence827); + } else { + throw new RuntimeException(("Illegal union index for 'F827': "+ unionIndex827)); + } + } + int unionIndex828 = (decoder.readIndex()); + if (unionIndex828 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(828, null); + } else { + if (unionIndex828 == 1) { + Utf8 charSequence828; + Object oldString828 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(828); + if (oldString828 instanceof Utf8) { + charSequence828 = (decoder).readString(((Utf8) oldString828)); + } else { + charSequence828 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(828, charSequence828); + } else { + throw new RuntimeException(("Illegal union index for 'F828': "+ unionIndex828)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex829 = (decoder.readIndex()); + if (unionIndex829 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(829, null); + } else { + if (unionIndex829 == 1) { + Utf8 charSequence829; + Object oldString829 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(829); + if (oldString829 instanceof Utf8) { + charSequence829 = (decoder).readString(((Utf8) oldString829)); + } else { + charSequence829 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(829, charSequence829); + } else { + throw new RuntimeException(("Illegal union index for 'F829': "+ unionIndex829)); + } + } + int unionIndex830 = (decoder.readIndex()); + if (unionIndex830 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(830, null); + } else { + if (unionIndex830 == 1) { + Utf8 charSequence830; + Object oldString830 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(830); + if (oldString830 instanceof Utf8) { + charSequence830 = (decoder).readString(((Utf8) oldString830)); + } else { + charSequence830 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(830, charSequence830); + } else { + throw new RuntimeException(("Illegal union index for 'F830': "+ unionIndex830)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex831 = (decoder.readIndex()); + if (unionIndex831 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(831, null); + } else { + if (unionIndex831 == 1) { + Utf8 charSequence831; + Object oldString831 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(831); + if (oldString831 instanceof Utf8) { + charSequence831 = (decoder).readString(((Utf8) oldString831)); + } else { + charSequence831 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(831, charSequence831); + } else { + throw new RuntimeException(("Illegal union index for 'F831': "+ unionIndex831)); + } + } + int unionIndex832 = (decoder.readIndex()); + if (unionIndex832 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(832, null); + } else { + if (unionIndex832 == 1) { + Utf8 charSequence832; + Object oldString832 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(832); + if (oldString832 instanceof Utf8) { + charSequence832 = (decoder).readString(((Utf8) oldString832)); + } else { + charSequence832 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(832, charSequence832); + } else { + throw new RuntimeException(("Illegal union index for 'F832': "+ unionIndex832)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex833 = (decoder.readIndex()); + if (unionIndex833 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(833, null); + } else { + if (unionIndex833 == 1) { + Utf8 charSequence833; + Object oldString833 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(833); + if (oldString833 instanceof Utf8) { + charSequence833 = (decoder).readString(((Utf8) oldString833)); + } else { + charSequence833 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(833, charSequence833); + } else { + throw new RuntimeException(("Illegal union index for 'F833': "+ unionIndex833)); + } + } + int unionIndex834 = (decoder.readIndex()); + if (unionIndex834 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(834, null); + } else { + if (unionIndex834 == 1) { + Utf8 charSequence834; + Object oldString834 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(834); + if (oldString834 instanceof Utf8) { + charSequence834 = (decoder).readString(((Utf8) oldString834)); + } else { + charSequence834 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(834, charSequence834); + } else { + throw new RuntimeException(("Illegal union index for 'F834': "+ unionIndex834)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex835 = (decoder.readIndex()); + if (unionIndex835 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(835, null); + } else { + if (unionIndex835 == 1) { + Utf8 charSequence835; + Object oldString835 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(835); + if (oldString835 instanceof Utf8) { + charSequence835 = (decoder).readString(((Utf8) oldString835)); + } else { + charSequence835 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(835, charSequence835); + } else { + throw new RuntimeException(("Illegal union index for 'F835': "+ unionIndex835)); + } + } + int unionIndex836 = (decoder.readIndex()); + if (unionIndex836 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(836, null); + } else { + if (unionIndex836 == 1) { + Utf8 charSequence836; + Object oldString836 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(836); + if (oldString836 instanceof Utf8) { + charSequence836 = (decoder).readString(((Utf8) oldString836)); + } else { + charSequence836 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(836, charSequence836); + } else { + throw new RuntimeException(("Illegal union index for 'F836': "+ unionIndex836)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex837 = (decoder.readIndex()); + if (unionIndex837 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(837, null); + } else { + if (unionIndex837 == 1) { + Utf8 charSequence837; + Object oldString837 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(837); + if (oldString837 instanceof Utf8) { + charSequence837 = (decoder).readString(((Utf8) oldString837)); + } else { + charSequence837 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(837, charSequence837); + } else { + throw new RuntimeException(("Illegal union index for 'F837': "+ unionIndex837)); + } + } + int unionIndex838 = (decoder.readIndex()); + if (unionIndex838 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(838, null); + } else { + if (unionIndex838 == 1) { + Utf8 charSequence838; + Object oldString838 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(838); + if (oldString838 instanceof Utf8) { + charSequence838 = (decoder).readString(((Utf8) oldString838)); + } else { + charSequence838 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(838, charSequence838); + } else { + throw new RuntimeException(("Illegal union index for 'F838': "+ unionIndex838)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex839 = (decoder.readIndex()); + if (unionIndex839 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(839, null); + } else { + if (unionIndex839 == 1) { + Utf8 charSequence839; + Object oldString839 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(839); + if (oldString839 instanceof Utf8) { + charSequence839 = (decoder).readString(((Utf8) oldString839)); + } else { + charSequence839 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(839, charSequence839); + } else { + throw new RuntimeException(("Illegal union index for 'F839': "+ unionIndex839)); + } + } + int unionIndex840 = (decoder.readIndex()); + if (unionIndex840 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(840, null); + } else { + if (unionIndex840 == 1) { + Utf8 charSequence840; + Object oldString840 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(840); + if (oldString840 instanceof Utf8) { + charSequence840 = (decoder).readString(((Utf8) oldString840)); + } else { + charSequence840 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(840, charSequence840); + } else { + throw new RuntimeException(("Illegal union index for 'F840': "+ unionIndex840)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex841 = (decoder.readIndex()); + if (unionIndex841 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(841, null); + } else { + if (unionIndex841 == 1) { + Utf8 charSequence841; + Object oldString841 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(841); + if (oldString841 instanceof Utf8) { + charSequence841 = (decoder).readString(((Utf8) oldString841)); + } else { + charSequence841 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(841, charSequence841); + } else { + throw new RuntimeException(("Illegal union index for 'F841': "+ unionIndex841)); + } + } + int unionIndex842 = (decoder.readIndex()); + if (unionIndex842 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(842, null); + } else { + if (unionIndex842 == 1) { + Utf8 charSequence842; + Object oldString842 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(842); + if (oldString842 instanceof Utf8) { + charSequence842 = (decoder).readString(((Utf8) oldString842)); + } else { + charSequence842 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(842, charSequence842); + } else { + throw new RuntimeException(("Illegal union index for 'F842': "+ unionIndex842)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex843 = (decoder.readIndex()); + if (unionIndex843 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(843, null); + } else { + if (unionIndex843 == 1) { + Utf8 charSequence843; + Object oldString843 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(843); + if (oldString843 instanceof Utf8) { + charSequence843 = (decoder).readString(((Utf8) oldString843)); + } else { + charSequence843 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(843, charSequence843); + } else { + throw new RuntimeException(("Illegal union index for 'F843': "+ unionIndex843)); + } + } + int unionIndex844 = (decoder.readIndex()); + if (unionIndex844 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(844, null); + } else { + if (unionIndex844 == 1) { + Utf8 charSequence844; + Object oldString844 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(844); + if (oldString844 instanceof Utf8) { + charSequence844 = (decoder).readString(((Utf8) oldString844)); + } else { + charSequence844 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(844, charSequence844); + } else { + throw new RuntimeException(("Illegal union index for 'F844': "+ unionIndex844)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex845 = (decoder.readIndex()); + if (unionIndex845 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(845, null); + } else { + if (unionIndex845 == 1) { + Utf8 charSequence845; + Object oldString845 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(845); + if (oldString845 instanceof Utf8) { + charSequence845 = (decoder).readString(((Utf8) oldString845)); + } else { + charSequence845 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(845, charSequence845); + } else { + throw new RuntimeException(("Illegal union index for 'F845': "+ unionIndex845)); + } + } + int unionIndex846 = (decoder.readIndex()); + if (unionIndex846 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(846, null); + } else { + if (unionIndex846 == 1) { + Utf8 charSequence846; + Object oldString846 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(846); + if (oldString846 instanceof Utf8) { + charSequence846 = (decoder).readString(((Utf8) oldString846)); + } else { + charSequence846 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(846, charSequence846); + } else { + throw new RuntimeException(("Illegal union index for 'F846': "+ unionIndex846)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex847 = (decoder.readIndex()); + if (unionIndex847 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(847, null); + } else { + if (unionIndex847 == 1) { + Utf8 charSequence847; + Object oldString847 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(847); + if (oldString847 instanceof Utf8) { + charSequence847 = (decoder).readString(((Utf8) oldString847)); + } else { + charSequence847 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(847, charSequence847); + } else { + throw new RuntimeException(("Illegal union index for 'F847': "+ unionIndex847)); + } + } + int unionIndex848 = (decoder.readIndex()); + if (unionIndex848 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(848, null); + } else { + if (unionIndex848 == 1) { + Utf8 charSequence848; + Object oldString848 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(848); + if (oldString848 instanceof Utf8) { + charSequence848 = (decoder).readString(((Utf8) oldString848)); + } else { + charSequence848 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(848, charSequence848); + } else { + throw new RuntimeException(("Illegal union index for 'F848': "+ unionIndex848)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex849 = (decoder.readIndex()); + if (unionIndex849 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(849, null); + } else { + if (unionIndex849 == 1) { + Utf8 charSequence849; + Object oldString849 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(849); + if (oldString849 instanceof Utf8) { + charSequence849 = (decoder).readString(((Utf8) oldString849)); + } else { + charSequence849 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(849, charSequence849); + } else { + throw new RuntimeException(("Illegal union index for 'F849': "+ unionIndex849)); + } + } + int unionIndex850 = (decoder.readIndex()); + if (unionIndex850 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(850, null); + } else { + if (unionIndex850 == 1) { + Utf8 charSequence850; + Object oldString850 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(850); + if (oldString850 instanceof Utf8) { + charSequence850 = (decoder).readString(((Utf8) oldString850)); + } else { + charSequence850 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(850, charSequence850); + } else { + throw new RuntimeException(("Illegal union index for 'F850': "+ unionIndex850)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex851 = (decoder.readIndex()); + if (unionIndex851 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(851, null); + } else { + if (unionIndex851 == 1) { + Utf8 charSequence851; + Object oldString851 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(851); + if (oldString851 instanceof Utf8) { + charSequence851 = (decoder).readString(((Utf8) oldString851)); + } else { + charSequence851 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(851, charSequence851); + } else { + throw new RuntimeException(("Illegal union index for 'F851': "+ unionIndex851)); + } + } + int unionIndex852 = (decoder.readIndex()); + if (unionIndex852 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(852, null); + } else { + if (unionIndex852 == 1) { + Utf8 charSequence852; + Object oldString852 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(852); + if (oldString852 instanceof Utf8) { + charSequence852 = (decoder).readString(((Utf8) oldString852)); + } else { + charSequence852 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(852, charSequence852); + } else { + throw new RuntimeException(("Illegal union index for 'F852': "+ unionIndex852)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex853 = (decoder.readIndex()); + if (unionIndex853 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(853, null); + } else { + if (unionIndex853 == 1) { + Utf8 charSequence853; + Object oldString853 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(853); + if (oldString853 instanceof Utf8) { + charSequence853 = (decoder).readString(((Utf8) oldString853)); + } else { + charSequence853 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(853, charSequence853); + } else { + throw new RuntimeException(("Illegal union index for 'F853': "+ unionIndex853)); + } + } + int unionIndex854 = (decoder.readIndex()); + if (unionIndex854 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(854, null); + } else { + if (unionIndex854 == 1) { + Utf8 charSequence854; + Object oldString854 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(854); + if (oldString854 instanceof Utf8) { + charSequence854 = (decoder).readString(((Utf8) oldString854)); + } else { + charSequence854 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(854, charSequence854); + } else { + throw new RuntimeException(("Illegal union index for 'F854': "+ unionIndex854)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex855 = (decoder.readIndex()); + if (unionIndex855 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(855, null); + } else { + if (unionIndex855 == 1) { + Utf8 charSequence855; + Object oldString855 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(855); + if (oldString855 instanceof Utf8) { + charSequence855 = (decoder).readString(((Utf8) oldString855)); + } else { + charSequence855 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(855, charSequence855); + } else { + throw new RuntimeException(("Illegal union index for 'F855': "+ unionIndex855)); + } + } + int unionIndex856 = (decoder.readIndex()); + if (unionIndex856 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(856, null); + } else { + if (unionIndex856 == 1) { + Utf8 charSequence856; + Object oldString856 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(856); + if (oldString856 instanceof Utf8) { + charSequence856 = (decoder).readString(((Utf8) oldString856)); + } else { + charSequence856 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(856, charSequence856); + } else { + throw new RuntimeException(("Illegal union index for 'F856': "+ unionIndex856)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex857 = (decoder.readIndex()); + if (unionIndex857 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(857, null); + } else { + if (unionIndex857 == 1) { + Utf8 charSequence857; + Object oldString857 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(857); + if (oldString857 instanceof Utf8) { + charSequence857 = (decoder).readString(((Utf8) oldString857)); + } else { + charSequence857 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(857, charSequence857); + } else { + throw new RuntimeException(("Illegal union index for 'F857': "+ unionIndex857)); + } + } + int unionIndex858 = (decoder.readIndex()); + if (unionIndex858 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(858, null); + } else { + if (unionIndex858 == 1) { + Utf8 charSequence858; + Object oldString858 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(858); + if (oldString858 instanceof Utf8) { + charSequence858 = (decoder).readString(((Utf8) oldString858)); + } else { + charSequence858 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(858, charSequence858); + } else { + throw new RuntimeException(("Illegal union index for 'F858': "+ unionIndex858)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex859 = (decoder.readIndex()); + if (unionIndex859 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(859, null); + } else { + if (unionIndex859 == 1) { + Utf8 charSequence859; + Object oldString859 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(859); + if (oldString859 instanceof Utf8) { + charSequence859 = (decoder).readString(((Utf8) oldString859)); + } else { + charSequence859 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(859, charSequence859); + } else { + throw new RuntimeException(("Illegal union index for 'F859': "+ unionIndex859)); + } + } + int unionIndex860 = (decoder.readIndex()); + if (unionIndex860 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(860, null); + } else { + if (unionIndex860 == 1) { + Utf8 charSequence860; + Object oldString860 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(860); + if (oldString860 instanceof Utf8) { + charSequence860 = (decoder).readString(((Utf8) oldString860)); + } else { + charSequence860 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(860, charSequence860); + } else { + throw new RuntimeException(("Illegal union index for 'F860': "+ unionIndex860)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex861 = (decoder.readIndex()); + if (unionIndex861 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(861, null); + } else { + if (unionIndex861 == 1) { + Utf8 charSequence861; + Object oldString861 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(861); + if (oldString861 instanceof Utf8) { + charSequence861 = (decoder).readString(((Utf8) oldString861)); + } else { + charSequence861 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(861, charSequence861); + } else { + throw new RuntimeException(("Illegal union index for 'F861': "+ unionIndex861)); + } + } + int unionIndex862 = (decoder.readIndex()); + if (unionIndex862 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(862, null); + } else { + if (unionIndex862 == 1) { + Utf8 charSequence862; + Object oldString862 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(862); + if (oldString862 instanceof Utf8) { + charSequence862 = (decoder).readString(((Utf8) oldString862)); + } else { + charSequence862 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(862, charSequence862); + } else { + throw new RuntimeException(("Illegal union index for 'F862': "+ unionIndex862)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex863 = (decoder.readIndex()); + if (unionIndex863 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(863, null); + } else { + if (unionIndex863 == 1) { + Utf8 charSequence863; + Object oldString863 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(863); + if (oldString863 instanceof Utf8) { + charSequence863 = (decoder).readString(((Utf8) oldString863)); + } else { + charSequence863 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(863, charSequence863); + } else { + throw new RuntimeException(("Illegal union index for 'F863': "+ unionIndex863)); + } + } + int unionIndex864 = (decoder.readIndex()); + if (unionIndex864 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(864, null); + } else { + if (unionIndex864 == 1) { + Utf8 charSequence864; + Object oldString864 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(864); + if (oldString864 instanceof Utf8) { + charSequence864 = (decoder).readString(((Utf8) oldString864)); + } else { + charSequence864 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(864, charSequence864); + } else { + throw new RuntimeException(("Illegal union index for 'F864': "+ unionIndex864)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex865 = (decoder.readIndex()); + if (unionIndex865 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(865, null); + } else { + if (unionIndex865 == 1) { + Utf8 charSequence865; + Object oldString865 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(865); + if (oldString865 instanceof Utf8) { + charSequence865 = (decoder).readString(((Utf8) oldString865)); + } else { + charSequence865 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(865, charSequence865); + } else { + throw new RuntimeException(("Illegal union index for 'F865': "+ unionIndex865)); + } + } + int unionIndex866 = (decoder.readIndex()); + if (unionIndex866 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(866, null); + } else { + if (unionIndex866 == 1) { + Utf8 charSequence866; + Object oldString866 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(866); + if (oldString866 instanceof Utf8) { + charSequence866 = (decoder).readString(((Utf8) oldString866)); + } else { + charSequence866 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(866, charSequence866); + } else { + throw new RuntimeException(("Illegal union index for 'F866': "+ unionIndex866)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex867 = (decoder.readIndex()); + if (unionIndex867 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(867, null); + } else { + if (unionIndex867 == 1) { + Utf8 charSequence867; + Object oldString867 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(867); + if (oldString867 instanceof Utf8) { + charSequence867 = (decoder).readString(((Utf8) oldString867)); + } else { + charSequence867 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(867, charSequence867); + } else { + throw new RuntimeException(("Illegal union index for 'F867': "+ unionIndex867)); + } + } + int unionIndex868 = (decoder.readIndex()); + if (unionIndex868 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(868, null); + } else { + if (unionIndex868 == 1) { + Utf8 charSequence868; + Object oldString868 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(868); + if (oldString868 instanceof Utf8) { + charSequence868 = (decoder).readString(((Utf8) oldString868)); + } else { + charSequence868 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(868, charSequence868); + } else { + throw new RuntimeException(("Illegal union index for 'F868': "+ unionIndex868)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex869 = (decoder.readIndex()); + if (unionIndex869 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(869, null); + } else { + if (unionIndex869 == 1) { + Utf8 charSequence869; + Object oldString869 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(869); + if (oldString869 instanceof Utf8) { + charSequence869 = (decoder).readString(((Utf8) oldString869)); + } else { + charSequence869 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(869, charSequence869); + } else { + throw new RuntimeException(("Illegal union index for 'F869': "+ unionIndex869)); + } + } + int unionIndex870 = (decoder.readIndex()); + if (unionIndex870 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(870, null); + } else { + if (unionIndex870 == 1) { + Utf8 charSequence870; + Object oldString870 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(870); + if (oldString870 instanceof Utf8) { + charSequence870 = (decoder).readString(((Utf8) oldString870)); + } else { + charSequence870 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(870, charSequence870); + } else { + throw new RuntimeException(("Illegal union index for 'F870': "+ unionIndex870)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex871 = (decoder.readIndex()); + if (unionIndex871 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(871, null); + } else { + if (unionIndex871 == 1) { + Utf8 charSequence871; + Object oldString871 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(871); + if (oldString871 instanceof Utf8) { + charSequence871 = (decoder).readString(((Utf8) oldString871)); + } else { + charSequence871 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(871, charSequence871); + } else { + throw new RuntimeException(("Illegal union index for 'F871': "+ unionIndex871)); + } + } + int unionIndex872 = (decoder.readIndex()); + if (unionIndex872 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(872, null); + } else { + if (unionIndex872 == 1) { + Utf8 charSequence872; + Object oldString872 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(872); + if (oldString872 instanceof Utf8) { + charSequence872 = (decoder).readString(((Utf8) oldString872)); + } else { + charSequence872 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(872, charSequence872); + } else { + throw new RuntimeException(("Illegal union index for 'F872': "+ unionIndex872)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex873 = (decoder.readIndex()); + if (unionIndex873 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(873, null); + } else { + if (unionIndex873 == 1) { + Utf8 charSequence873; + Object oldString873 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(873); + if (oldString873 instanceof Utf8) { + charSequence873 = (decoder).readString(((Utf8) oldString873)); + } else { + charSequence873 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(873, charSequence873); + } else { + throw new RuntimeException(("Illegal union index for 'F873': "+ unionIndex873)); + } + } + int unionIndex874 = (decoder.readIndex()); + if (unionIndex874 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(874, null); + } else { + if (unionIndex874 == 1) { + Utf8 charSequence874; + Object oldString874 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(874); + if (oldString874 instanceof Utf8) { + charSequence874 = (decoder).readString(((Utf8) oldString874)); + } else { + charSequence874 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(874, charSequence874); + } else { + throw new RuntimeException(("Illegal union index for 'F874': "+ unionIndex874)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex875 = (decoder.readIndex()); + if (unionIndex875 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(875, null); + } else { + if (unionIndex875 == 1) { + Utf8 charSequence875; + Object oldString875 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(875); + if (oldString875 instanceof Utf8) { + charSequence875 = (decoder).readString(((Utf8) oldString875)); + } else { + charSequence875 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(875, charSequence875); + } else { + throw new RuntimeException(("Illegal union index for 'F875': "+ unionIndex875)); + } + } + int unionIndex876 = (decoder.readIndex()); + if (unionIndex876 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(876, null); + } else { + if (unionIndex876 == 1) { + Utf8 charSequence876; + Object oldString876 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(876); + if (oldString876 instanceof Utf8) { + charSequence876 = (decoder).readString(((Utf8) oldString876)); + } else { + charSequence876 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(876, charSequence876); + } else { + throw new RuntimeException(("Illegal union index for 'F876': "+ unionIndex876)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex877 = (decoder.readIndex()); + if (unionIndex877 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(877, null); + } else { + if (unionIndex877 == 1) { + Utf8 charSequence877; + Object oldString877 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(877); + if (oldString877 instanceof Utf8) { + charSequence877 = (decoder).readString(((Utf8) oldString877)); + } else { + charSequence877 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(877, charSequence877); + } else { + throw new RuntimeException(("Illegal union index for 'F877': "+ unionIndex877)); + } + } + int unionIndex878 = (decoder.readIndex()); + if (unionIndex878 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(878, null); + } else { + if (unionIndex878 == 1) { + Utf8 charSequence878; + Object oldString878 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(878); + if (oldString878 instanceof Utf8) { + charSequence878 = (decoder).readString(((Utf8) oldString878)); + } else { + charSequence878 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(878, charSequence878); + } else { + throw new RuntimeException(("Illegal union index for 'F878': "+ unionIndex878)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex879 = (decoder.readIndex()); + if (unionIndex879 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(879, null); + } else { + if (unionIndex879 == 1) { + Utf8 charSequence879; + Object oldString879 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(879); + if (oldString879 instanceof Utf8) { + charSequence879 = (decoder).readString(((Utf8) oldString879)); + } else { + charSequence879 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(879, charSequence879); + } else { + throw new RuntimeException(("Illegal union index for 'F879': "+ unionIndex879)); + } + } + int unionIndex880 = (decoder.readIndex()); + if (unionIndex880 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(880, null); + } else { + if (unionIndex880 == 1) { + Utf8 charSequence880; + Object oldString880 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(880); + if (oldString880 instanceof Utf8) { + charSequence880 = (decoder).readString(((Utf8) oldString880)); + } else { + charSequence880 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(880, charSequence880); + } else { + throw new RuntimeException(("Illegal union index for 'F880': "+ unionIndex880)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex881 = (decoder.readIndex()); + if (unionIndex881 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(881, null); + } else { + if (unionIndex881 == 1) { + Utf8 charSequence881; + Object oldString881 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(881); + if (oldString881 instanceof Utf8) { + charSequence881 = (decoder).readString(((Utf8) oldString881)); + } else { + charSequence881 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(881, charSequence881); + } else { + throw new RuntimeException(("Illegal union index for 'F881': "+ unionIndex881)); + } + } + int unionIndex882 = (decoder.readIndex()); + if (unionIndex882 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(882, null); + } else { + if (unionIndex882 == 1) { + Utf8 charSequence882; + Object oldString882 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(882); + if (oldString882 instanceof Utf8) { + charSequence882 = (decoder).readString(((Utf8) oldString882)); + } else { + charSequence882 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(882, charSequence882); + } else { + throw new RuntimeException(("Illegal union index for 'F882': "+ unionIndex882)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex883 = (decoder.readIndex()); + if (unionIndex883 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(883, null); + } else { + if (unionIndex883 == 1) { + Utf8 charSequence883; + Object oldString883 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(883); + if (oldString883 instanceof Utf8) { + charSequence883 = (decoder).readString(((Utf8) oldString883)); + } else { + charSequence883 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(883, charSequence883); + } else { + throw new RuntimeException(("Illegal union index for 'F883': "+ unionIndex883)); + } + } + int unionIndex884 = (decoder.readIndex()); + if (unionIndex884 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(884, null); + } else { + if (unionIndex884 == 1) { + Utf8 charSequence884; + Object oldString884 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(884); + if (oldString884 instanceof Utf8) { + charSequence884 = (decoder).readString(((Utf8) oldString884)); + } else { + charSequence884 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(884, charSequence884); + } else { + throw new RuntimeException(("Illegal union index for 'F884': "+ unionIndex884)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex885 = (decoder.readIndex()); + if (unionIndex885 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(885, null); + } else { + if (unionIndex885 == 1) { + Utf8 charSequence885; + Object oldString885 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(885); + if (oldString885 instanceof Utf8) { + charSequence885 = (decoder).readString(((Utf8) oldString885)); + } else { + charSequence885 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(885, charSequence885); + } else { + throw new RuntimeException(("Illegal union index for 'F885': "+ unionIndex885)); + } + } + int unionIndex886 = (decoder.readIndex()); + if (unionIndex886 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(886, null); + } else { + if (unionIndex886 == 1) { + Utf8 charSequence886; + Object oldString886 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(886); + if (oldString886 instanceof Utf8) { + charSequence886 = (decoder).readString(((Utf8) oldString886)); + } else { + charSequence886 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(886, charSequence886); + } else { + throw new RuntimeException(("Illegal union index for 'F886': "+ unionIndex886)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex887 = (decoder.readIndex()); + if (unionIndex887 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(887, null); + } else { + if (unionIndex887 == 1) { + Utf8 charSequence887; + Object oldString887 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(887); + if (oldString887 instanceof Utf8) { + charSequence887 = (decoder).readString(((Utf8) oldString887)); + } else { + charSequence887 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(887, charSequence887); + } else { + throw new RuntimeException(("Illegal union index for 'F887': "+ unionIndex887)); + } + } + int unionIndex888 = (decoder.readIndex()); + if (unionIndex888 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(888, null); + } else { + if (unionIndex888 == 1) { + Utf8 charSequence888; + Object oldString888 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(888); + if (oldString888 instanceof Utf8) { + charSequence888 = (decoder).readString(((Utf8) oldString888)); + } else { + charSequence888 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(888, charSequence888); + } else { + throw new RuntimeException(("Illegal union index for 'F888': "+ unionIndex888)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex889 = (decoder.readIndex()); + if (unionIndex889 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(889, null); + } else { + if (unionIndex889 == 1) { + Utf8 charSequence889; + Object oldString889 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(889); + if (oldString889 instanceof Utf8) { + charSequence889 = (decoder).readString(((Utf8) oldString889)); + } else { + charSequence889 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(889, charSequence889); + } else { + throw new RuntimeException(("Illegal union index for 'F889': "+ unionIndex889)); + } + } + int unionIndex890 = (decoder.readIndex()); + if (unionIndex890 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(890, null); + } else { + if (unionIndex890 == 1) { + Utf8 charSequence890; + Object oldString890 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(890); + if (oldString890 instanceof Utf8) { + charSequence890 = (decoder).readString(((Utf8) oldString890)); + } else { + charSequence890 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(890, charSequence890); + } else { + throw new RuntimeException(("Illegal union index for 'F890': "+ unionIndex890)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex891 = (decoder.readIndex()); + if (unionIndex891 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(891, null); + } else { + if (unionIndex891 == 1) { + Utf8 charSequence891; + Object oldString891 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(891); + if (oldString891 instanceof Utf8) { + charSequence891 = (decoder).readString(((Utf8) oldString891)); + } else { + charSequence891 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(891, charSequence891); + } else { + throw new RuntimeException(("Illegal union index for 'F891': "+ unionIndex891)); + } + } + int unionIndex892 = (decoder.readIndex()); + if (unionIndex892 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(892, null); + } else { + if (unionIndex892 == 1) { + Utf8 charSequence892; + Object oldString892 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(892); + if (oldString892 instanceof Utf8) { + charSequence892 = (decoder).readString(((Utf8) oldString892)); + } else { + charSequence892 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(892, charSequence892); + } else { + throw new RuntimeException(("Illegal union index for 'F892': "+ unionIndex892)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex893 = (decoder.readIndex()); + if (unionIndex893 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(893, null); + } else { + if (unionIndex893 == 1) { + Utf8 charSequence893; + Object oldString893 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(893); + if (oldString893 instanceof Utf8) { + charSequence893 = (decoder).readString(((Utf8) oldString893)); + } else { + charSequence893 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(893, charSequence893); + } else { + throw new RuntimeException(("Illegal union index for 'F893': "+ unionIndex893)); + } + } + int unionIndex894 = (decoder.readIndex()); + if (unionIndex894 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(894, null); + } else { + if (unionIndex894 == 1) { + Utf8 charSequence894; + Object oldString894 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(894); + if (oldString894 instanceof Utf8) { + charSequence894 = (decoder).readString(((Utf8) oldString894)); + } else { + charSequence894 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(894, charSequence894); + } else { + throw new RuntimeException(("Illegal union index for 'F894': "+ unionIndex894)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex895 = (decoder.readIndex()); + if (unionIndex895 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(895, null); + } else { + if (unionIndex895 == 1) { + Utf8 charSequence895; + Object oldString895 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(895); + if (oldString895 instanceof Utf8) { + charSequence895 = (decoder).readString(((Utf8) oldString895)); + } else { + charSequence895 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(895, charSequence895); + } else { + throw new RuntimeException(("Illegal union index for 'F895': "+ unionIndex895)); + } + } + int unionIndex896 = (decoder.readIndex()); + if (unionIndex896 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(896, null); + } else { + if (unionIndex896 == 1) { + Utf8 charSequence896; + Object oldString896 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(896); + if (oldString896 instanceof Utf8) { + charSequence896 = (decoder).readString(((Utf8) oldString896)); + } else { + charSequence896 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(896, charSequence896); + } else { + throw new RuntimeException(("Illegal union index for 'F896': "+ unionIndex896)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex897 = (decoder.readIndex()); + if (unionIndex897 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(897, null); + } else { + if (unionIndex897 == 1) { + Utf8 charSequence897; + Object oldString897 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(897); + if (oldString897 instanceof Utf8) { + charSequence897 = (decoder).readString(((Utf8) oldString897)); + } else { + charSequence897 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(897, charSequence897); + } else { + throw new RuntimeException(("Illegal union index for 'F897': "+ unionIndex897)); + } + } + int unionIndex898 = (decoder.readIndex()); + if (unionIndex898 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(898, null); + } else { + if (unionIndex898 == 1) { + Utf8 charSequence898; + Object oldString898 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(898); + if (oldString898 instanceof Utf8) { + charSequence898 = (decoder).readString(((Utf8) oldString898)); + } else { + charSequence898 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(898, charSequence898); + } else { + throw new RuntimeException(("Illegal union index for 'F898': "+ unionIndex898)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex899 = (decoder.readIndex()); + if (unionIndex899 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(899, null); + } else { + if (unionIndex899 == 1) { + Utf8 charSequence899; + Object oldString899 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(899); + if (oldString899 instanceof Utf8) { + charSequence899 = (decoder).readString(((Utf8) oldString899)); + } else { + charSequence899 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(899, charSequence899); + } else { + throw new RuntimeException(("Illegal union index for 'F899': "+ unionIndex899)); + } + } + int unionIndex900 = (decoder.readIndex()); + if (unionIndex900 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(900, null); + } else { + if (unionIndex900 == 1) { + Utf8 charSequence900; + Object oldString900 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(900); + if (oldString900 instanceof Utf8) { + charSequence900 = (decoder).readString(((Utf8) oldString900)); + } else { + charSequence900 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(900, charSequence900); + } else { + throw new RuntimeException(("Illegal union index for 'F900': "+ unionIndex900)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex901 = (decoder.readIndex()); + if (unionIndex901 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(901, null); + } else { + if (unionIndex901 == 1) { + Utf8 charSequence901; + Object oldString901 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(901); + if (oldString901 instanceof Utf8) { + charSequence901 = (decoder).readString(((Utf8) oldString901)); + } else { + charSequence901 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(901, charSequence901); + } else { + throw new RuntimeException(("Illegal union index for 'F901': "+ unionIndex901)); + } + } + int unionIndex902 = (decoder.readIndex()); + if (unionIndex902 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(902, null); + } else { + if (unionIndex902 == 1) { + Utf8 charSequence902; + Object oldString902 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(902); + if (oldString902 instanceof Utf8) { + charSequence902 = (decoder).readString(((Utf8) oldString902)); + } else { + charSequence902 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(902, charSequence902); + } else { + throw new RuntimeException(("Illegal union index for 'F902': "+ unionIndex902)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex903 = (decoder.readIndex()); + if (unionIndex903 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(903, null); + } else { + if (unionIndex903 == 1) { + Utf8 charSequence903; + Object oldString903 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(903); + if (oldString903 instanceof Utf8) { + charSequence903 = (decoder).readString(((Utf8) oldString903)); + } else { + charSequence903 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(903, charSequence903); + } else { + throw new RuntimeException(("Illegal union index for 'F903': "+ unionIndex903)); + } + } + int unionIndex904 = (decoder.readIndex()); + if (unionIndex904 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(904, null); + } else { + if (unionIndex904 == 1) { + Utf8 charSequence904; + Object oldString904 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(904); + if (oldString904 instanceof Utf8) { + charSequence904 = (decoder).readString(((Utf8) oldString904)); + } else { + charSequence904 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(904, charSequence904); + } else { + throw new RuntimeException(("Illegal union index for 'F904': "+ unionIndex904)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex905 = (decoder.readIndex()); + if (unionIndex905 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(905, null); + } else { + if (unionIndex905 == 1) { + Utf8 charSequence905; + Object oldString905 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(905); + if (oldString905 instanceof Utf8) { + charSequence905 = (decoder).readString(((Utf8) oldString905)); + } else { + charSequence905 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(905, charSequence905); + } else { + throw new RuntimeException(("Illegal union index for 'F905': "+ unionIndex905)); + } + } + int unionIndex906 = (decoder.readIndex()); + if (unionIndex906 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(906, null); + } else { + if (unionIndex906 == 1) { + Utf8 charSequence906; + Object oldString906 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(906); + if (oldString906 instanceof Utf8) { + charSequence906 = (decoder).readString(((Utf8) oldString906)); + } else { + charSequence906 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(906, charSequence906); + } else { + throw new RuntimeException(("Illegal union index for 'F906': "+ unionIndex906)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex907 = (decoder.readIndex()); + if (unionIndex907 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(907, null); + } else { + if (unionIndex907 == 1) { + Utf8 charSequence907; + Object oldString907 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(907); + if (oldString907 instanceof Utf8) { + charSequence907 = (decoder).readString(((Utf8) oldString907)); + } else { + charSequence907 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(907, charSequence907); + } else { + throw new RuntimeException(("Illegal union index for 'F907': "+ unionIndex907)); + } + } + int unionIndex908 = (decoder.readIndex()); + if (unionIndex908 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(908, null); + } else { + if (unionIndex908 == 1) { + Utf8 charSequence908; + Object oldString908 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(908); + if (oldString908 instanceof Utf8) { + charSequence908 = (decoder).readString(((Utf8) oldString908)); + } else { + charSequence908 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(908, charSequence908); + } else { + throw new RuntimeException(("Illegal union index for 'F908': "+ unionIndex908)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex909 = (decoder.readIndex()); + if (unionIndex909 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(909, null); + } else { + if (unionIndex909 == 1) { + Utf8 charSequence909; + Object oldString909 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(909); + if (oldString909 instanceof Utf8) { + charSequence909 = (decoder).readString(((Utf8) oldString909)); + } else { + charSequence909 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(909, charSequence909); + } else { + throw new RuntimeException(("Illegal union index for 'F909': "+ unionIndex909)); + } + } + int unionIndex910 = (decoder.readIndex()); + if (unionIndex910 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(910, null); + } else { + if (unionIndex910 == 1) { + Utf8 charSequence910; + Object oldString910 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(910); + if (oldString910 instanceof Utf8) { + charSequence910 = (decoder).readString(((Utf8) oldString910)); + } else { + charSequence910 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(910, charSequence910); + } else { + throw new RuntimeException(("Illegal union index for 'F910': "+ unionIndex910)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex911 = (decoder.readIndex()); + if (unionIndex911 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(911, null); + } else { + if (unionIndex911 == 1) { + Utf8 charSequence911; + Object oldString911 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(911); + if (oldString911 instanceof Utf8) { + charSequence911 = (decoder).readString(((Utf8) oldString911)); + } else { + charSequence911 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(911, charSequence911); + } else { + throw new RuntimeException(("Illegal union index for 'F911': "+ unionIndex911)); + } + } + int unionIndex912 = (decoder.readIndex()); + if (unionIndex912 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(912, null); + } else { + if (unionIndex912 == 1) { + Utf8 charSequence912; + Object oldString912 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(912); + if (oldString912 instanceof Utf8) { + charSequence912 = (decoder).readString(((Utf8) oldString912)); + } else { + charSequence912 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(912, charSequence912); + } else { + throw new RuntimeException(("Illegal union index for 'F912': "+ unionIndex912)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex913 = (decoder.readIndex()); + if (unionIndex913 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(913, null); + } else { + if (unionIndex913 == 1) { + Utf8 charSequence913; + Object oldString913 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(913); + if (oldString913 instanceof Utf8) { + charSequence913 = (decoder).readString(((Utf8) oldString913)); + } else { + charSequence913 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(913, charSequence913); + } else { + throw new RuntimeException(("Illegal union index for 'F913': "+ unionIndex913)); + } + } + int unionIndex914 = (decoder.readIndex()); + if (unionIndex914 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(914, null); + } else { + if (unionIndex914 == 1) { + Utf8 charSequence914; + Object oldString914 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(914); + if (oldString914 instanceof Utf8) { + charSequence914 = (decoder).readString(((Utf8) oldString914)); + } else { + charSequence914 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(914, charSequence914); + } else { + throw new RuntimeException(("Illegal union index for 'F914': "+ unionIndex914)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex915 = (decoder.readIndex()); + if (unionIndex915 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(915, null); + } else { + if (unionIndex915 == 1) { + Utf8 charSequence915; + Object oldString915 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(915); + if (oldString915 instanceof Utf8) { + charSequence915 = (decoder).readString(((Utf8) oldString915)); + } else { + charSequence915 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(915, charSequence915); + } else { + throw new RuntimeException(("Illegal union index for 'F915': "+ unionIndex915)); + } + } + int unionIndex916 = (decoder.readIndex()); + if (unionIndex916 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(916, null); + } else { + if (unionIndex916 == 1) { + Utf8 charSequence916; + Object oldString916 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(916); + if (oldString916 instanceof Utf8) { + charSequence916 = (decoder).readString(((Utf8) oldString916)); + } else { + charSequence916 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(916, charSequence916); + } else { + throw new RuntimeException(("Illegal union index for 'F916': "+ unionIndex916)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex917 = (decoder.readIndex()); + if (unionIndex917 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(917, null); + } else { + if (unionIndex917 == 1) { + Utf8 charSequence917; + Object oldString917 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(917); + if (oldString917 instanceof Utf8) { + charSequence917 = (decoder).readString(((Utf8) oldString917)); + } else { + charSequence917 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(917, charSequence917); + } else { + throw new RuntimeException(("Illegal union index for 'F917': "+ unionIndex917)); + } + } + int unionIndex918 = (decoder.readIndex()); + if (unionIndex918 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(918, null); + } else { + if (unionIndex918 == 1) { + Utf8 charSequence918; + Object oldString918 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(918); + if (oldString918 instanceof Utf8) { + charSequence918 = (decoder).readString(((Utf8) oldString918)); + } else { + charSequence918 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(918, charSequence918); + } else { + throw new RuntimeException(("Illegal union index for 'F918': "+ unionIndex918)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex919 = (decoder.readIndex()); + if (unionIndex919 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(919, null); + } else { + if (unionIndex919 == 1) { + Utf8 charSequence919; + Object oldString919 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(919); + if (oldString919 instanceof Utf8) { + charSequence919 = (decoder).readString(((Utf8) oldString919)); + } else { + charSequence919 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(919, charSequence919); + } else { + throw new RuntimeException(("Illegal union index for 'F919': "+ unionIndex919)); + } + } + int unionIndex920 = (decoder.readIndex()); + if (unionIndex920 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(920, null); + } else { + if (unionIndex920 == 1) { + Utf8 charSequence920; + Object oldString920 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(920); + if (oldString920 instanceof Utf8) { + charSequence920 = (decoder).readString(((Utf8) oldString920)); + } else { + charSequence920 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(920, charSequence920); + } else { + throw new RuntimeException(("Illegal union index for 'F920': "+ unionIndex920)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex921 = (decoder.readIndex()); + if (unionIndex921 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(921, null); + } else { + if (unionIndex921 == 1) { + Utf8 charSequence921; + Object oldString921 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(921); + if (oldString921 instanceof Utf8) { + charSequence921 = (decoder).readString(((Utf8) oldString921)); + } else { + charSequence921 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(921, charSequence921); + } else { + throw new RuntimeException(("Illegal union index for 'F921': "+ unionIndex921)); + } + } + int unionIndex922 = (decoder.readIndex()); + if (unionIndex922 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(922, null); + } else { + if (unionIndex922 == 1) { + Utf8 charSequence922; + Object oldString922 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(922); + if (oldString922 instanceof Utf8) { + charSequence922 = (decoder).readString(((Utf8) oldString922)); + } else { + charSequence922 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(922, charSequence922); + } else { + throw new RuntimeException(("Illegal union index for 'F922': "+ unionIndex922)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex923 = (decoder.readIndex()); + if (unionIndex923 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(923, null); + } else { + if (unionIndex923 == 1) { + Utf8 charSequence923; + Object oldString923 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(923); + if (oldString923 instanceof Utf8) { + charSequence923 = (decoder).readString(((Utf8) oldString923)); + } else { + charSequence923 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(923, charSequence923); + } else { + throw new RuntimeException(("Illegal union index for 'F923': "+ unionIndex923)); + } + } + int unionIndex924 = (decoder.readIndex()); + if (unionIndex924 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(924, null); + } else { + if (unionIndex924 == 1) { + Utf8 charSequence924; + Object oldString924 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(924); + if (oldString924 instanceof Utf8) { + charSequence924 = (decoder).readString(((Utf8) oldString924)); + } else { + charSequence924 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(924, charSequence924); + } else { + throw new RuntimeException(("Illegal union index for 'F924': "+ unionIndex924)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex925 = (decoder.readIndex()); + if (unionIndex925 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(925, null); + } else { + if (unionIndex925 == 1) { + Utf8 charSequence925; + Object oldString925 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(925); + if (oldString925 instanceof Utf8) { + charSequence925 = (decoder).readString(((Utf8) oldString925)); + } else { + charSequence925 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(925, charSequence925); + } else { + throw new RuntimeException(("Illegal union index for 'F925': "+ unionIndex925)); + } + } + int unionIndex926 = (decoder.readIndex()); + if (unionIndex926 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(926, null); + } else { + if (unionIndex926 == 1) { + Utf8 charSequence926; + Object oldString926 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(926); + if (oldString926 instanceof Utf8) { + charSequence926 = (decoder).readString(((Utf8) oldString926)); + } else { + charSequence926 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(926, charSequence926); + } else { + throw new RuntimeException(("Illegal union index for 'F926': "+ unionIndex926)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex927 = (decoder.readIndex()); + if (unionIndex927 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(927, null); + } else { + if (unionIndex927 == 1) { + Utf8 charSequence927; + Object oldString927 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(927); + if (oldString927 instanceof Utf8) { + charSequence927 = (decoder).readString(((Utf8) oldString927)); + } else { + charSequence927 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(927, charSequence927); + } else { + throw new RuntimeException(("Illegal union index for 'F927': "+ unionIndex927)); + } + } + int unionIndex928 = (decoder.readIndex()); + if (unionIndex928 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(928, null); + } else { + if (unionIndex928 == 1) { + Utf8 charSequence928; + Object oldString928 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(928); + if (oldString928 instanceof Utf8) { + charSequence928 = (decoder).readString(((Utf8) oldString928)); + } else { + charSequence928 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(928, charSequence928); + } else { + throw new RuntimeException(("Illegal union index for 'F928': "+ unionIndex928)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex929 = (decoder.readIndex()); + if (unionIndex929 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(929, null); + } else { + if (unionIndex929 == 1) { + Utf8 charSequence929; + Object oldString929 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(929); + if (oldString929 instanceof Utf8) { + charSequence929 = (decoder).readString(((Utf8) oldString929)); + } else { + charSequence929 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(929, charSequence929); + } else { + throw new RuntimeException(("Illegal union index for 'F929': "+ unionIndex929)); + } + } + int unionIndex930 = (decoder.readIndex()); + if (unionIndex930 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(930, null); + } else { + if (unionIndex930 == 1) { + Utf8 charSequence930; + Object oldString930 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(930); + if (oldString930 instanceof Utf8) { + charSequence930 = (decoder).readString(((Utf8) oldString930)); + } else { + charSequence930 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(930, charSequence930); + } else { + throw new RuntimeException(("Illegal union index for 'F930': "+ unionIndex930)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex931 = (decoder.readIndex()); + if (unionIndex931 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(931, null); + } else { + if (unionIndex931 == 1) { + Utf8 charSequence931; + Object oldString931 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(931); + if (oldString931 instanceof Utf8) { + charSequence931 = (decoder).readString(((Utf8) oldString931)); + } else { + charSequence931 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(931, charSequence931); + } else { + throw new RuntimeException(("Illegal union index for 'F931': "+ unionIndex931)); + } + } + int unionIndex932 = (decoder.readIndex()); + if (unionIndex932 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(932, null); + } else { + if (unionIndex932 == 1) { + Utf8 charSequence932; + Object oldString932 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(932); + if (oldString932 instanceof Utf8) { + charSequence932 = (decoder).readString(((Utf8) oldString932)); + } else { + charSequence932 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(932, charSequence932); + } else { + throw new RuntimeException(("Illegal union index for 'F932': "+ unionIndex932)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex933 = (decoder.readIndex()); + if (unionIndex933 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(933, null); + } else { + if (unionIndex933 == 1) { + Utf8 charSequence933; + Object oldString933 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(933); + if (oldString933 instanceof Utf8) { + charSequence933 = (decoder).readString(((Utf8) oldString933)); + } else { + charSequence933 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(933, charSequence933); + } else { + throw new RuntimeException(("Illegal union index for 'F933': "+ unionIndex933)); + } + } + int unionIndex934 = (decoder.readIndex()); + if (unionIndex934 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(934, null); + } else { + if (unionIndex934 == 1) { + Utf8 charSequence934; + Object oldString934 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(934); + if (oldString934 instanceof Utf8) { + charSequence934 = (decoder).readString(((Utf8) oldString934)); + } else { + charSequence934 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(934, charSequence934); + } else { + throw new RuntimeException(("Illegal union index for 'F934': "+ unionIndex934)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex935 = (decoder.readIndex()); + if (unionIndex935 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(935, null); + } else { + if (unionIndex935 == 1) { + Utf8 charSequence935; + Object oldString935 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(935); + if (oldString935 instanceof Utf8) { + charSequence935 = (decoder).readString(((Utf8) oldString935)); + } else { + charSequence935 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(935, charSequence935); + } else { + throw new RuntimeException(("Illegal union index for 'F935': "+ unionIndex935)); + } + } + int unionIndex936 = (decoder.readIndex()); + if (unionIndex936 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(936, null); + } else { + if (unionIndex936 == 1) { + Utf8 charSequence936; + Object oldString936 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(936); + if (oldString936 instanceof Utf8) { + charSequence936 = (decoder).readString(((Utf8) oldString936)); + } else { + charSequence936 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(936, charSequence936); + } else { + throw new RuntimeException(("Illegal union index for 'F936': "+ unionIndex936)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex937 = (decoder.readIndex()); + if (unionIndex937 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(937, null); + } else { + if (unionIndex937 == 1) { + Utf8 charSequence937; + Object oldString937 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(937); + if (oldString937 instanceof Utf8) { + charSequence937 = (decoder).readString(((Utf8) oldString937)); + } else { + charSequence937 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(937, charSequence937); + } else { + throw new RuntimeException(("Illegal union index for 'F937': "+ unionIndex937)); + } + } + int unionIndex938 = (decoder.readIndex()); + if (unionIndex938 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(938, null); + } else { + if (unionIndex938 == 1) { + Utf8 charSequence938; + Object oldString938 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(938); + if (oldString938 instanceof Utf8) { + charSequence938 = (decoder).readString(((Utf8) oldString938)); + } else { + charSequence938 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(938, charSequence938); + } else { + throw new RuntimeException(("Illegal union index for 'F938': "+ unionIndex938)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex939 = (decoder.readIndex()); + if (unionIndex939 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(939, null); + } else { + if (unionIndex939 == 1) { + Utf8 charSequence939; + Object oldString939 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(939); + if (oldString939 instanceof Utf8) { + charSequence939 = (decoder).readString(((Utf8) oldString939)); + } else { + charSequence939 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(939, charSequence939); + } else { + throw new RuntimeException(("Illegal union index for 'F939': "+ unionIndex939)); + } + } + int unionIndex940 = (decoder.readIndex()); + if (unionIndex940 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(940, null); + } else { + if (unionIndex940 == 1) { + Utf8 charSequence940; + Object oldString940 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(940); + if (oldString940 instanceof Utf8) { + charSequence940 = (decoder).readString(((Utf8) oldString940)); + } else { + charSequence940 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(940, charSequence940); + } else { + throw new RuntimeException(("Illegal union index for 'F940': "+ unionIndex940)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex941 = (decoder.readIndex()); + if (unionIndex941 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(941, null); + } else { + if (unionIndex941 == 1) { + Utf8 charSequence941; + Object oldString941 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(941); + if (oldString941 instanceof Utf8) { + charSequence941 = (decoder).readString(((Utf8) oldString941)); + } else { + charSequence941 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(941, charSequence941); + } else { + throw new RuntimeException(("Illegal union index for 'F941': "+ unionIndex941)); + } + } + int unionIndex942 = (decoder.readIndex()); + if (unionIndex942 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(942, null); + } else { + if (unionIndex942 == 1) { + Utf8 charSequence942; + Object oldString942 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(942); + if (oldString942 instanceof Utf8) { + charSequence942 = (decoder).readString(((Utf8) oldString942)); + } else { + charSequence942 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(942, charSequence942); + } else { + throw new RuntimeException(("Illegal union index for 'F942': "+ unionIndex942)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex943 = (decoder.readIndex()); + if (unionIndex943 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(943, null); + } else { + if (unionIndex943 == 1) { + Utf8 charSequence943; + Object oldString943 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(943); + if (oldString943 instanceof Utf8) { + charSequence943 = (decoder).readString(((Utf8) oldString943)); + } else { + charSequence943 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(943, charSequence943); + } else { + throw new RuntimeException(("Illegal union index for 'F943': "+ unionIndex943)); + } + } + int unionIndex944 = (decoder.readIndex()); + if (unionIndex944 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(944, null); + } else { + if (unionIndex944 == 1) { + Utf8 charSequence944; + Object oldString944 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(944); + if (oldString944 instanceof Utf8) { + charSequence944 = (decoder).readString(((Utf8) oldString944)); + } else { + charSequence944 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(944, charSequence944); + } else { + throw new RuntimeException(("Illegal union index for 'F944': "+ unionIndex944)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex945 = (decoder.readIndex()); + if (unionIndex945 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(945, null); + } else { + if (unionIndex945 == 1) { + Utf8 charSequence945; + Object oldString945 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(945); + if (oldString945 instanceof Utf8) { + charSequence945 = (decoder).readString(((Utf8) oldString945)); + } else { + charSequence945 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(945, charSequence945); + } else { + throw new RuntimeException(("Illegal union index for 'F945': "+ unionIndex945)); + } + } + int unionIndex946 = (decoder.readIndex()); + if (unionIndex946 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(946, null); + } else { + if (unionIndex946 == 1) { + Utf8 charSequence946; + Object oldString946 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(946); + if (oldString946 instanceof Utf8) { + charSequence946 = (decoder).readString(((Utf8) oldString946)); + } else { + charSequence946 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(946, charSequence946); + } else { + throw new RuntimeException(("Illegal union index for 'F946': "+ unionIndex946)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex947 = (decoder.readIndex()); + if (unionIndex947 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(947, null); + } else { + if (unionIndex947 == 1) { + Utf8 charSequence947; + Object oldString947 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(947); + if (oldString947 instanceof Utf8) { + charSequence947 = (decoder).readString(((Utf8) oldString947)); + } else { + charSequence947 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(947, charSequence947); + } else { + throw new RuntimeException(("Illegal union index for 'F947': "+ unionIndex947)); + } + } + int unionIndex948 = (decoder.readIndex()); + if (unionIndex948 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(948, null); + } else { + if (unionIndex948 == 1) { + Utf8 charSequence948; + Object oldString948 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(948); + if (oldString948 instanceof Utf8) { + charSequence948 = (decoder).readString(((Utf8) oldString948)); + } else { + charSequence948 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(948, charSequence948); + } else { + throw new RuntimeException(("Illegal union index for 'F948': "+ unionIndex948)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex949 = (decoder.readIndex()); + if (unionIndex949 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(949, null); + } else { + if (unionIndex949 == 1) { + Utf8 charSequence949; + Object oldString949 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(949); + if (oldString949 instanceof Utf8) { + charSequence949 = (decoder).readString(((Utf8) oldString949)); + } else { + charSequence949 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(949, charSequence949); + } else { + throw new RuntimeException(("Illegal union index for 'F949': "+ unionIndex949)); + } + } + int unionIndex950 = (decoder.readIndex()); + if (unionIndex950 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(950, null); + } else { + if (unionIndex950 == 1) { + Utf8 charSequence950; + Object oldString950 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(950); + if (oldString950 instanceof Utf8) { + charSequence950 = (decoder).readString(((Utf8) oldString950)); + } else { + charSequence950 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(950, charSequence950); + } else { + throw new RuntimeException(("Illegal union index for 'F950': "+ unionIndex950)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex951 = (decoder.readIndex()); + if (unionIndex951 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(951, null); + } else { + if (unionIndex951 == 1) { + Utf8 charSequence951; + Object oldString951 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(951); + if (oldString951 instanceof Utf8) { + charSequence951 = (decoder).readString(((Utf8) oldString951)); + } else { + charSequence951 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(951, charSequence951); + } else { + throw new RuntimeException(("Illegal union index for 'F951': "+ unionIndex951)); + } + } + int unionIndex952 = (decoder.readIndex()); + if (unionIndex952 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(952, null); + } else { + if (unionIndex952 == 1) { + Utf8 charSequence952; + Object oldString952 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(952); + if (oldString952 instanceof Utf8) { + charSequence952 = (decoder).readString(((Utf8) oldString952)); + } else { + charSequence952 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(952, charSequence952); + } else { + throw new RuntimeException(("Illegal union index for 'F952': "+ unionIndex952)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex953 = (decoder.readIndex()); + if (unionIndex953 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(953, null); + } else { + if (unionIndex953 == 1) { + Utf8 charSequence953; + Object oldString953 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(953); + if (oldString953 instanceof Utf8) { + charSequence953 = (decoder).readString(((Utf8) oldString953)); + } else { + charSequence953 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(953, charSequence953); + } else { + throw new RuntimeException(("Illegal union index for 'F953': "+ unionIndex953)); + } + } + int unionIndex954 = (decoder.readIndex()); + if (unionIndex954 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(954, null); + } else { + if (unionIndex954 == 1) { + Utf8 charSequence954; + Object oldString954 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(954); + if (oldString954 instanceof Utf8) { + charSequence954 = (decoder).readString(((Utf8) oldString954)); + } else { + charSequence954 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(954, charSequence954); + } else { + throw new RuntimeException(("Illegal union index for 'F954': "+ unionIndex954)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex955 = (decoder.readIndex()); + if (unionIndex955 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(955, null); + } else { + if (unionIndex955 == 1) { + Utf8 charSequence955; + Object oldString955 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(955); + if (oldString955 instanceof Utf8) { + charSequence955 = (decoder).readString(((Utf8) oldString955)); + } else { + charSequence955 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(955, charSequence955); + } else { + throw new RuntimeException(("Illegal union index for 'F955': "+ unionIndex955)); + } + } + int unionIndex956 = (decoder.readIndex()); + if (unionIndex956 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(956, null); + } else { + if (unionIndex956 == 1) { + Utf8 charSequence956; + Object oldString956 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(956); + if (oldString956 instanceof Utf8) { + charSequence956 = (decoder).readString(((Utf8) oldString956)); + } else { + charSequence956 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(956, charSequence956); + } else { + throw new RuntimeException(("Illegal union index for 'F956': "+ unionIndex956)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex957 = (decoder.readIndex()); + if (unionIndex957 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(957, null); + } else { + if (unionIndex957 == 1) { + Utf8 charSequence957; + Object oldString957 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(957); + if (oldString957 instanceof Utf8) { + charSequence957 = (decoder).readString(((Utf8) oldString957)); + } else { + charSequence957 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(957, charSequence957); + } else { + throw new RuntimeException(("Illegal union index for 'F957': "+ unionIndex957)); + } + } + int unionIndex958 = (decoder.readIndex()); + if (unionIndex958 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(958, null); + } else { + if (unionIndex958 == 1) { + Utf8 charSequence958; + Object oldString958 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(958); + if (oldString958 instanceof Utf8) { + charSequence958 = (decoder).readString(((Utf8) oldString958)); + } else { + charSequence958 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(958, charSequence958); + } else { + throw new RuntimeException(("Illegal union index for 'F958': "+ unionIndex958)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex959 = (decoder.readIndex()); + if (unionIndex959 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(959, null); + } else { + if (unionIndex959 == 1) { + Utf8 charSequence959; + Object oldString959 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(959); + if (oldString959 instanceof Utf8) { + charSequence959 = (decoder).readString(((Utf8) oldString959)); + } else { + charSequence959 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(959, charSequence959); + } else { + throw new RuntimeException(("Illegal union index for 'F959': "+ unionIndex959)); + } + } + int unionIndex960 = (decoder.readIndex()); + if (unionIndex960 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(960, null); + } else { + if (unionIndex960 == 1) { + Utf8 charSequence960; + Object oldString960 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(960); + if (oldString960 instanceof Utf8) { + charSequence960 = (decoder).readString(((Utf8) oldString960)); + } else { + charSequence960 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(960, charSequence960); + } else { + throw new RuntimeException(("Illegal union index for 'F960': "+ unionIndex960)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex961 = (decoder.readIndex()); + if (unionIndex961 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(961, null); + } else { + if (unionIndex961 == 1) { + Utf8 charSequence961; + Object oldString961 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(961); + if (oldString961 instanceof Utf8) { + charSequence961 = (decoder).readString(((Utf8) oldString961)); + } else { + charSequence961 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(961, charSequence961); + } else { + throw new RuntimeException(("Illegal union index for 'F961': "+ unionIndex961)); + } + } + int unionIndex962 = (decoder.readIndex()); + if (unionIndex962 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(962, null); + } else { + if (unionIndex962 == 1) { + Utf8 charSequence962; + Object oldString962 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(962); + if (oldString962 instanceof Utf8) { + charSequence962 = (decoder).readString(((Utf8) oldString962)); + } else { + charSequence962 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(962, charSequence962); + } else { + throw new RuntimeException(("Illegal union index for 'F962': "+ unionIndex962)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex963 = (decoder.readIndex()); + if (unionIndex963 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(963, null); + } else { + if (unionIndex963 == 1) { + Utf8 charSequence963; + Object oldString963 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(963); + if (oldString963 instanceof Utf8) { + charSequence963 = (decoder).readString(((Utf8) oldString963)); + } else { + charSequence963 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(963, charSequence963); + } else { + throw new RuntimeException(("Illegal union index for 'F963': "+ unionIndex963)); + } + } + int unionIndex964 = (decoder.readIndex()); + if (unionIndex964 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(964, null); + } else { + if (unionIndex964 == 1) { + Utf8 charSequence964; + Object oldString964 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(964); + if (oldString964 instanceof Utf8) { + charSequence964 = (decoder).readString(((Utf8) oldString964)); + } else { + charSequence964 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(964, charSequence964); + } else { + throw new RuntimeException(("Illegal union index for 'F964': "+ unionIndex964)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex965 = (decoder.readIndex()); + if (unionIndex965 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(965, null); + } else { + if (unionIndex965 == 1) { + Utf8 charSequence965; + Object oldString965 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(965); + if (oldString965 instanceof Utf8) { + charSequence965 = (decoder).readString(((Utf8) oldString965)); + } else { + charSequence965 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(965, charSequence965); + } else { + throw new RuntimeException(("Illegal union index for 'F965': "+ unionIndex965)); + } + } + int unionIndex966 = (decoder.readIndex()); + if (unionIndex966 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(966, null); + } else { + if (unionIndex966 == 1) { + Utf8 charSequence966; + Object oldString966 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(966); + if (oldString966 instanceof Utf8) { + charSequence966 = (decoder).readString(((Utf8) oldString966)); + } else { + charSequence966 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(966, charSequence966); + } else { + throw new RuntimeException(("Illegal union index for 'F966': "+ unionIndex966)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex967 = (decoder.readIndex()); + if (unionIndex967 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(967, null); + } else { + if (unionIndex967 == 1) { + Utf8 charSequence967; + Object oldString967 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(967); + if (oldString967 instanceof Utf8) { + charSequence967 = (decoder).readString(((Utf8) oldString967)); + } else { + charSequence967 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(967, charSequence967); + } else { + throw new RuntimeException(("Illegal union index for 'F967': "+ unionIndex967)); + } + } + int unionIndex968 = (decoder.readIndex()); + if (unionIndex968 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(968, null); + } else { + if (unionIndex968 == 1) { + Utf8 charSequence968; + Object oldString968 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(968); + if (oldString968 instanceof Utf8) { + charSequence968 = (decoder).readString(((Utf8) oldString968)); + } else { + charSequence968 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(968, charSequence968); + } else { + throw new RuntimeException(("Illegal union index for 'F968': "+ unionIndex968)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex969 = (decoder.readIndex()); + if (unionIndex969 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(969, null); + } else { + if (unionIndex969 == 1) { + Utf8 charSequence969; + Object oldString969 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(969); + if (oldString969 instanceof Utf8) { + charSequence969 = (decoder).readString(((Utf8) oldString969)); + } else { + charSequence969 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(969, charSequence969); + } else { + throw new RuntimeException(("Illegal union index for 'F969': "+ unionIndex969)); + } + } + int unionIndex970 = (decoder.readIndex()); + if (unionIndex970 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(970, null); + } else { + if (unionIndex970 == 1) { + Utf8 charSequence970; + Object oldString970 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(970); + if (oldString970 instanceof Utf8) { + charSequence970 = (decoder).readString(((Utf8) oldString970)); + } else { + charSequence970 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(970, charSequence970); + } else { + throw new RuntimeException(("Illegal union index for 'F970': "+ unionIndex970)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex971 = (decoder.readIndex()); + if (unionIndex971 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(971, null); + } else { + if (unionIndex971 == 1) { + Utf8 charSequence971; + Object oldString971 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(971); + if (oldString971 instanceof Utf8) { + charSequence971 = (decoder).readString(((Utf8) oldString971)); + } else { + charSequence971 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(971, charSequence971); + } else { + throw new RuntimeException(("Illegal union index for 'F971': "+ unionIndex971)); + } + } + int unionIndex972 = (decoder.readIndex()); + if (unionIndex972 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(972, null); + } else { + if (unionIndex972 == 1) { + Utf8 charSequence972; + Object oldString972 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(972); + if (oldString972 instanceof Utf8) { + charSequence972 = (decoder).readString(((Utf8) oldString972)); + } else { + charSequence972 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(972, charSequence972); + } else { + throw new RuntimeException(("Illegal union index for 'F972': "+ unionIndex972)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex973 = (decoder.readIndex()); + if (unionIndex973 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(973, null); + } else { + if (unionIndex973 == 1) { + Utf8 charSequence973; + Object oldString973 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(973); + if (oldString973 instanceof Utf8) { + charSequence973 = (decoder).readString(((Utf8) oldString973)); + } else { + charSequence973 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(973, charSequence973); + } else { + throw new RuntimeException(("Illegal union index for 'F973': "+ unionIndex973)); + } + } + int unionIndex974 = (decoder.readIndex()); + if (unionIndex974 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(974, null); + } else { + if (unionIndex974 == 1) { + Utf8 charSequence974; + Object oldString974 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(974); + if (oldString974 instanceof Utf8) { + charSequence974 = (decoder).readString(((Utf8) oldString974)); + } else { + charSequence974 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(974, charSequence974); + } else { + throw new RuntimeException(("Illegal union index for 'F974': "+ unionIndex974)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex975 = (decoder.readIndex()); + if (unionIndex975 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(975, null); + } else { + if (unionIndex975 == 1) { + Utf8 charSequence975; + Object oldString975 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(975); + if (oldString975 instanceof Utf8) { + charSequence975 = (decoder).readString(((Utf8) oldString975)); + } else { + charSequence975 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(975, charSequence975); + } else { + throw new RuntimeException(("Illegal union index for 'F975': "+ unionIndex975)); + } + } + int unionIndex976 = (decoder.readIndex()); + if (unionIndex976 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(976, null); + } else { + if (unionIndex976 == 1) { + Utf8 charSequence976; + Object oldString976 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(976); + if (oldString976 instanceof Utf8) { + charSequence976 = (decoder).readString(((Utf8) oldString976)); + } else { + charSequence976 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(976, charSequence976); + } else { + throw new RuntimeException(("Illegal union index for 'F976': "+ unionIndex976)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex977 = (decoder.readIndex()); + if (unionIndex977 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(977, null); + } else { + if (unionIndex977 == 1) { + Utf8 charSequence977; + Object oldString977 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(977); + if (oldString977 instanceof Utf8) { + charSequence977 = (decoder).readString(((Utf8) oldString977)); + } else { + charSequence977 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(977, charSequence977); + } else { + throw new RuntimeException(("Illegal union index for 'F977': "+ unionIndex977)); + } + } + int unionIndex978 = (decoder.readIndex()); + if (unionIndex978 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(978, null); + } else { + if (unionIndex978 == 1) { + Utf8 charSequence978; + Object oldString978 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(978); + if (oldString978 instanceof Utf8) { + charSequence978 = (decoder).readString(((Utf8) oldString978)); + } else { + charSequence978 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(978, charSequence978); + } else { + throw new RuntimeException(("Illegal union index for 'F978': "+ unionIndex978)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex979 = (decoder.readIndex()); + if (unionIndex979 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(979, null); + } else { + if (unionIndex979 == 1) { + Utf8 charSequence979; + Object oldString979 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(979); + if (oldString979 instanceof Utf8) { + charSequence979 = (decoder).readString(((Utf8) oldString979)); + } else { + charSequence979 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(979, charSequence979); + } else { + throw new RuntimeException(("Illegal union index for 'F979': "+ unionIndex979)); + } + } + int unionIndex980 = (decoder.readIndex()); + if (unionIndex980 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(980, null); + } else { + if (unionIndex980 == 1) { + Utf8 charSequence980; + Object oldString980 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(980); + if (oldString980 instanceof Utf8) { + charSequence980 = (decoder).readString(((Utf8) oldString980)); + } else { + charSequence980 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(980, charSequence980); + } else { + throw new RuntimeException(("Illegal union index for 'F980': "+ unionIndex980)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex981 = (decoder.readIndex()); + if (unionIndex981 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(981, null); + } else { + if (unionIndex981 == 1) { + Utf8 charSequence981; + Object oldString981 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(981); + if (oldString981 instanceof Utf8) { + charSequence981 = (decoder).readString(((Utf8) oldString981)); + } else { + charSequence981 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(981, charSequence981); + } else { + throw new RuntimeException(("Illegal union index for 'F981': "+ unionIndex981)); + } + } + int unionIndex982 = (decoder.readIndex()); + if (unionIndex982 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(982, null); + } else { + if (unionIndex982 == 1) { + Utf8 charSequence982; + Object oldString982 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(982); + if (oldString982 instanceof Utf8) { + charSequence982 = (decoder).readString(((Utf8) oldString982)); + } else { + charSequence982 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(982, charSequence982); + } else { + throw new RuntimeException(("Illegal union index for 'F982': "+ unionIndex982)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex983 = (decoder.readIndex()); + if (unionIndex983 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(983, null); + } else { + if (unionIndex983 == 1) { + Utf8 charSequence983; + Object oldString983 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(983); + if (oldString983 instanceof Utf8) { + charSequence983 = (decoder).readString(((Utf8) oldString983)); + } else { + charSequence983 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(983, charSequence983); + } else { + throw new RuntimeException(("Illegal union index for 'F983': "+ unionIndex983)); + } + } + int unionIndex984 = (decoder.readIndex()); + if (unionIndex984 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(984, null); + } else { + if (unionIndex984 == 1) { + Utf8 charSequence984; + Object oldString984 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(984); + if (oldString984 instanceof Utf8) { + charSequence984 = (decoder).readString(((Utf8) oldString984)); + } else { + charSequence984 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(984, charSequence984); + } else { + throw new RuntimeException(("Illegal union index for 'F984': "+ unionIndex984)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex985 = (decoder.readIndex()); + if (unionIndex985 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(985, null); + } else { + if (unionIndex985 == 1) { + Utf8 charSequence985; + Object oldString985 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(985); + if (oldString985 instanceof Utf8) { + charSequence985 = (decoder).readString(((Utf8) oldString985)); + } else { + charSequence985 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(985, charSequence985); + } else { + throw new RuntimeException(("Illegal union index for 'F985': "+ unionIndex985)); + } + } + int unionIndex986 = (decoder.readIndex()); + if (unionIndex986 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(986, null); + } else { + if (unionIndex986 == 1) { + Utf8 charSequence986; + Object oldString986 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(986); + if (oldString986 instanceof Utf8) { + charSequence986 = (decoder).readString(((Utf8) oldString986)); + } else { + charSequence986 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(986, charSequence986); + } else { + throw new RuntimeException(("Illegal union index for 'F986': "+ unionIndex986)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex987 = (decoder.readIndex()); + if (unionIndex987 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(987, null); + } else { + if (unionIndex987 == 1) { + Utf8 charSequence987; + Object oldString987 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(987); + if (oldString987 instanceof Utf8) { + charSequence987 = (decoder).readString(((Utf8) oldString987)); + } else { + charSequence987 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(987, charSequence987); + } else { + throw new RuntimeException(("Illegal union index for 'F987': "+ unionIndex987)); + } + } + int unionIndex988 = (decoder.readIndex()); + if (unionIndex988 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(988, null); + } else { + if (unionIndex988 == 1) { + Utf8 charSequence988; + Object oldString988 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(988); + if (oldString988 instanceof Utf8) { + charSequence988 = (decoder).readString(((Utf8) oldString988)); + } else { + charSequence988 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(988, charSequence988); + } else { + throw new RuntimeException(("Illegal union index for 'F988': "+ unionIndex988)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex989 = (decoder.readIndex()); + if (unionIndex989 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(989, null); + } else { + if (unionIndex989 == 1) { + Utf8 charSequence989; + Object oldString989 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(989); + if (oldString989 instanceof Utf8) { + charSequence989 = (decoder).readString(((Utf8) oldString989)); + } else { + charSequence989 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(989, charSequence989); + } else { + throw new RuntimeException(("Illegal union index for 'F989': "+ unionIndex989)); + } + } + int unionIndex990 = (decoder.readIndex()); + if (unionIndex990 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(990, null); + } else { + if (unionIndex990 == 1) { + Utf8 charSequence990; + Object oldString990 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(990); + if (oldString990 instanceof Utf8) { + charSequence990 = (decoder).readString(((Utf8) oldString990)); + } else { + charSequence990 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(990, charSequence990); + } else { + throw new RuntimeException(("Illegal union index for 'F990': "+ unionIndex990)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex991 = (decoder.readIndex()); + if (unionIndex991 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(991, null); + } else { + if (unionIndex991 == 1) { + Utf8 charSequence991; + Object oldString991 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(991); + if (oldString991 instanceof Utf8) { + charSequence991 = (decoder).readString(((Utf8) oldString991)); + } else { + charSequence991 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(991, charSequence991); + } else { + throw new RuntimeException(("Illegal union index for 'F991': "+ unionIndex991)); + } + } + int unionIndex992 = (decoder.readIndex()); + if (unionIndex992 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(992, null); + } else { + if (unionIndex992 == 1) { + Utf8 charSequence992; + Object oldString992 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(992); + if (oldString992 instanceof Utf8) { + charSequence992 = (decoder).readString(((Utf8) oldString992)); + } else { + charSequence992 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(992, charSequence992); + } else { + throw new RuntimeException(("Illegal union index for 'F992': "+ unionIndex992)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex993 = (decoder.readIndex()); + if (unionIndex993 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(993, null); + } else { + if (unionIndex993 == 1) { + Utf8 charSequence993; + Object oldString993 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(993); + if (oldString993 instanceof Utf8) { + charSequence993 = (decoder).readString(((Utf8) oldString993)); + } else { + charSequence993 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(993, charSequence993); + } else { + throw new RuntimeException(("Illegal union index for 'F993': "+ unionIndex993)); + } + } + int unionIndex994 = (decoder.readIndex()); + if (unionIndex994 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(994, null); + } else { + if (unionIndex994 == 1) { + Utf8 charSequence994; + Object oldString994 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(994); + if (oldString994 instanceof Utf8) { + charSequence994 = (decoder).readString(((Utf8) oldString994)); + } else { + charSequence994 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(994, charSequence994); + } else { + throw new RuntimeException(("Illegal union index for 'F994': "+ unionIndex994)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex995 = (decoder.readIndex()); + if (unionIndex995 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(995, null); + } else { + if (unionIndex995 == 1) { + Utf8 charSequence995; + Object oldString995 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(995); + if (oldString995 instanceof Utf8) { + charSequence995 = (decoder).readString(((Utf8) oldString995)); + } else { + charSequence995 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(995, charSequence995); + } else { + throw new RuntimeException(("Illegal union index for 'F995': "+ unionIndex995)); + } + } + int unionIndex996 = (decoder.readIndex()); + if (unionIndex996 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(996, null); + } else { + if (unionIndex996 == 1) { + Utf8 charSequence996; + Object oldString996 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(996); + if (oldString996 instanceof Utf8) { + charSequence996 = (decoder).readString(((Utf8) oldString996)); + } else { + charSequence996 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(996, charSequence996); + } else { + throw new RuntimeException(("Illegal union index for 'F996': "+ unionIndex996)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex997 = (decoder.readIndex()); + if (unionIndex997 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(997, null); + } else { + if (unionIndex997 == 1) { + Utf8 charSequence997; + Object oldString997 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(997); + if (oldString997 instanceof Utf8) { + charSequence997 = (decoder).readString(((Utf8) oldString997)); + } else { + charSequence997 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(997, charSequence997); + } else { + throw new RuntimeException(("Illegal union index for 'F997': "+ unionIndex997)); + } + } + int unionIndex998 = (decoder.readIndex()); + if (unionIndex998 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(998, null); + } else { + if (unionIndex998 == 1) { + Utf8 charSequence998; + Object oldString998 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(998); + if (oldString998 instanceof Utf8) { + charSequence998 = (decoder).readString(((Utf8) oldString998)); + } else { + charSequence998 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(998, charSequence998); + } else { + throw new RuntimeException(("Illegal union index for 'F998': "+ unionIndex998)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex999 = (decoder.readIndex()); + if (unionIndex999 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(999, null); + } else { + if (unionIndex999 == 1) { + Utf8 charSequence999; + Object oldString999 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(999); + if (oldString999 instanceof Utf8) { + charSequence999 = (decoder).readString(((Utf8) oldString999)); + } else { + charSequence999 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(999, charSequence999); + } else { + throw new RuntimeException(("Illegal union index for 'F999': "+ unionIndex999)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java new file mode 100644 index 000000000..c8a15b1c8 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testString0; + private final Schema testStringUnionAlias0; + + public FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testString0 = readerSchema.getField("testString").schema(); + this.testStringUnionAlias0 = readerSchema.getField("testStringUnionAlias").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadAliasedField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadAliasedField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadAliasedField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadAliasedField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadAliasedField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldReadAliasedField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'testString': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0((FastGenericDeserializerGeneratorTest_shouldReadAliasedField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadAliasedField; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadAliasedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(1, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadAliasedField.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnionAlias': "+ unionIndex1)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java new file mode 100644 index 000000000..96dd21bec --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java @@ -0,0 +1,122 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Schema testEnumUnion0; + private final Schema testEnumArray0; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadEnum = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadEnum = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(0, new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get((decoder.readEnum())))); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum1((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(1, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(1, new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get((decoder.readEnum())))); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadEnum.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + testEnumArray1 .clear(); + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadEnum.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + testEnumUnionArray1 .clear(); + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testFixed0; + private final Schema testFixedUnion0; + private final Schema testFixedArray0; + private final Schema testFixedUnionArray0; + private final Schema testFixedUnionArrayArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadFixed_GenericDeserializer_1590965143_1590965143(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testFixed0 = readerSchema.getField("testFixed").schema(); + this.testFixedUnion0 = readerSchema.getField("testFixedUnion").schema(); + this.testFixedArray0 = readerSchema.getField("testFixedArray").schema(); + this.testFixedUnionArray0 = readerSchema.getField("testFixedUnionArray").schema(); + this.testFixedUnionArrayArrayElemSchema0 = testFixedUnionArray0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadFixed = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadFixed = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + byte[] testFixed1; + Object oldFixed0 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(0); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (2))) { + testFixed1 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed1 = ( new byte[2]); + } + decoder.readFixed(testFixed1); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(0, new org.apache.avro.generic.GenericData.Fixed(testFixed0, testFixed1)); + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed1((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadFixed; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(1, null); + } else { + if (unionIndex0 == 1) { + byte[] testFixed2; + Object oldFixed1 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(1); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (2))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[2]); + } + decoder.readFixed(testFixed2); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(1, new org.apache.avro.generic.GenericData.Fixed(testFixed0, testFixed2)); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex0)); + } + } + List testFixedArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(2); + if (oldArray0 instanceof List) { + testFixedArray1 = ((List) oldArray0); + testFixedArray1 .clear(); + } else { + testFixedArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testFixedArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(3); + if (oldArray1 instanceof List) { + testFixedUnionArray1 = ((List) oldArray1); + testFixedUnionArray1 .clear(); + } else { + testFixedUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testFixedUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema union0; + private final Schema unionOptionSchema0; + private final Schema subField0; + + public FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion_GenericDeserializer_2643982_2643982(Schema readerSchema) { + this.readerSchema = readerSchema; + this.union0 = readerSchema.getField("union").schema(); + this.unionOptionSchema0 = union0 .getTypes().get(1); + this.subField0 = unionOptionSchema0 .getField("subField").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, charSequence1); + } else { + if (unionIndex0 == 3) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + } + return FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == unionOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(unionOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java new file mode 100644 index 000000000..976d3b545 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java @@ -0,0 +1,129 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema mapField0; + private final Schema mapFieldMapValueSchema0; + private final Schema mapFieldValueMapValueSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapField0 = readerSchema.getField("mapField").schema(); + this.mapFieldMapValueSchema0 = mapField0 .getValueType(); + this.mapFieldValueMapValueSchema0 = mapFieldMapValueSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadNestedMap; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadNestedMap = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadNestedMap = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map>> mapField1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), ((int) chunkLen0))); + } else { + Map>> mapFieldReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0); + if (oldMap0 instanceof Map) { + mapFieldReuse0 = ((Map) oldMap0); + } + if (mapFieldReuse0 != (null)) { + mapFieldReuse0 .clear(); + mapField1 = mapFieldReuse0; + } else { + mapField1 = new HashMap>>(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 > mapFieldValue0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, ((int) chunkLen1))); + } else { + Map> mapFieldValueReuse0 = null; + if (null instanceof Map) { + mapFieldValueReuse0 = ((Map) null); + } + if (mapFieldValueReuse0 != (null)) { + mapFieldValueReuse0 .clear(); + mapFieldValue0 = mapFieldValueReuse0; + } else { + mapFieldValue0 = new HashMap>(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0) { + for (int counter2 = 0; (counter2 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, 0)); + } else { + mapFieldValue0 = new HashMap>(0); + } + } + mapField1 .put(key0, mapFieldValue0); + } + chunkLen0 = (decoder.mapNext()); + } while (chunkLen0 > 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), 0)); + } else { + mapField1 = new HashMap>>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadNestedMap.put(0, mapField1); + return FastGenericDeserializerGeneratorTest_shouldReadNestedMap; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java new file mode 100644 index 000000000..9eece5b23 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java @@ -0,0 +1,206 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + private final Schema testEnumUnion0; + private final Map enumMappingtestEnum1; + private final Schema testEnumArray0; + private final Map enumMappingtestEnum2; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + private final Map enumMappingtestEnum3; + + public FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(5); + tempEnumMapping0 .put(new Integer(0), new Integer(1)); + tempEnumMapping0 .put(new Integer(1), new Integer(0)); + tempEnumMapping0 .put(new Integer(2), new Integer(4)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + HashMap tempEnumMapping1 = new HashMap(5); + tempEnumMapping1 .put(new Integer(0), new Integer(1)); + tempEnumMapping1 .put(new Integer(1), new Integer(0)); + tempEnumMapping1 .put(new Integer(2), new Integer(4)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + HashMap tempEnumMapping2 = new HashMap(5); + tempEnumMapping2 .put(new Integer(0), new Integer(1)); + tempEnumMapping2 .put(new Integer(1), new Integer(0)); + tempEnumMapping2 .put(new Integer(2), new Integer(4)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + HashMap tempEnumMapping3 = new HashMap(5); + tempEnumMapping3 .put(new Integer(0), new Integer(1)); + tempEnumMapping3 .put(new Integer(1), new Integer(0)); + tempEnumMapping3 .put(new Integer(2), new Integer(4)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(0, enumValue0); + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum1((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(1, null); + } else { + if (unionIndex0 == 1) { + int enumIndex1 = (decoder.readEnum()); + GenericEnumSymbol enumValue1 = null; + Object enumIndexLookupResult1 = enumMappingtestEnum1 .get(enumIndex1); + if (enumIndexLookupResult1 instanceof Integer) { + enumValue1 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult1))); + } else { + if (enumIndexLookupResult1 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult1); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(1, enumValue1); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + testEnumArray1 .clear(); + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + testEnumUnionArray1 .clear(); + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testIntUnion0; + private final Schema testStringUnion0; + private final Schema testLongUnion0; + private final Schema testDoubleUnion0; + private final Schema testFloatUnion0; + private final Schema testBooleanUnion0; + private final Schema testBytesUnion0; + + public FastGenericDeserializerGeneratorTest_shouldReadPrimitives_GenericDeserializer_1966544736_1966544736(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testIntUnion0 = readerSchema.getField("testIntUnion").schema(); + this.testStringUnion0 = readerSchema.getField("testStringUnion").schema(); + this.testLongUnion0 = readerSchema.getField("testLongUnion").schema(); + this.testDoubleUnion0 = readerSchema.getField("testDoubleUnion").schema(); + this.testFloatUnion0 = readerSchema.getField("testFloatUnion").schema(); + this.testBooleanUnion0 = readerSchema.getField("testBooleanUnion").schema(); + this.testBytesUnion0 = readerSchema.getField("testBytesUnion").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(0, (decoder.readInt())); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPrimitives; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(1, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(2); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(2, charSequence0); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(3, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(3); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(3, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(4, (decoder.readLong())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(5, null); + } else { + if (unionIndex2 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(5, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex2)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(6, (decoder.readDouble())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(7, null); + } else { + if (unionIndex3 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(7, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex3)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(8, (decoder.readFloat())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(9, null); + } else { + if (unionIndex4 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(9, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex4)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(10, (decoder.readBoolean())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(11, null); + } else { + if (unionIndex5 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(11, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex5)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(12); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(12, byteBuffer0); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(13, null); + } else { + if (unionIndex6 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(13); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(13, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex6)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java new file mode 100644 index 000000000..fe5fa75c5 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java @@ -0,0 +1,160 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema record10; + private final Schema subField0; + private final Schema intFieldField0; + private final Schema intField0; + private final Schema subField1; + private final Schema recordArray0; + + public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record10 = readerSchema.getField("record1").schema(); + this.subField0 = record10 .getField("subField").schema(); + this.intFieldField0 = record10 .getField("intField").schema(); + this.intField0 = record10 .getField("intField").schema(); + this.subField1 = record10 .getField("subField").schema(); + this.recordArray0 = readerSchema.getField("recordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == record10)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(record10); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + subRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(1); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(1, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex0)); + } + } + subRecord.put(0, null); + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord1(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); + List recordArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); + if (oldArray0 instanceof List) { + recordArray1 = ((List) oldArray0); + recordArray1 .clear(); + } else { + recordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema record10; + private final Schema subField0; + private final Schema record20; + private final Schema intField0; + private final Schema subField1; + private final Schema recordArray0; + + public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1365753944_1274815349(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record10 = readerSchema.getField("record1").schema(); + this.subField0 = record10 .getField("subField").schema(); + this.record20 = readerSchema.getField("record2").schema(); + this.intField0 = record20 .getField("intField").schema(); + this.subField1 = record20 .getField("subField").schema(); + this.recordArray0 = readerSchema.getField("recordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializealiasedSubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializealiasedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord aliasedSubRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == record10)) { + aliasedSubRecord = ((IndexedRecord)(reuse)); + } else { + aliasedSubRecord = new org.apache.avro.generic.GenericData.Record(record10); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + decoder.readInt(); + } else { + throw new RuntimeException(("Illegal union index for 'intField': "+ unionIndex0)); + } + } + populate_aliasedSubRecord0((aliasedSubRecord), (customization), (decoder)); + return aliasedSubRecord; + } + + private void populate_aliasedSubRecord0(IndexedRecord aliasedSubRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + aliasedSubRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = aliasedSubRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + aliasedSubRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); + List recordArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); + if (oldArray0 instanceof List) { + recordArray1 = ((List) oldArray0); + recordArray1 .clear(); + } else { + recordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema recordsArray0; + private final Schema recordsArrayArrayElemSchema0; + private final Schema subField0; + private final Schema recordsMap0; + private final Schema recordsArrayUnion0; + private final Schema recordsArrayUnionOptionSchema0; + private final Schema recordsArrayUnionOptionArrayElemSchema0; + private final Schema recordsMapUnion0; + private final Schema recordsMapUnionOptionSchema0; + private final Schema recordsMapUnionOptionMapValueSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField_GenericDeserializer_1602399407_1602399407(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordsArray0 = readerSchema.getField("recordsArray").schema(); + this.recordsArrayArrayElemSchema0 = recordsArray0 .getElementType(); + this.subField0 = recordsArrayArrayElemSchema0 .getField("subField").schema(); + this.recordsMap0 = readerSchema.getField("recordsMap").schema(); + this.recordsArrayUnion0 = readerSchema.getField("recordsArrayUnion").schema(); + this.recordsArrayUnionOptionSchema0 = recordsArrayUnion0 .getTypes().get(1); + this.recordsArrayUnionOptionArrayElemSchema0 = recordsArrayUnionOptionSchema0 .getElementType(); + this.recordsMapUnion0 = readerSchema.getField("recordsMapUnion").schema(); + this.recordsMapUnionOptionSchema0 = recordsMapUnion0 .getTypes().get(1); + this.recordsMapUnionOptionMapValueSchema0 = recordsMapUnionOptionSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List recordsArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(0); + if (oldArray0 instanceof List) { + recordsArray1 = ((List) oldArray0); + recordsArray1 .clear(); + } else { + recordsArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordsArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 recordsMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), ((int) chunkLen1))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap1 = recordsMapReuse0; + } else { + recordsMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), 0)); + } else { + recordsMap1 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(1, recordsMap1); + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(2, null); + } else { + if (unionIndex1 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(2); + if (oldArray1 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray1); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen2), recordsArrayUnionOptionSchema0); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 recordsMapUnionOption0 = null; + long chunkLen3 = (decoder.readMapStart()); + if (chunkLen3 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), ((int) chunkLen3))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); + } + } + do { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(3, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex3)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java new file mode 100644 index 000000000..20ffce71d --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java @@ -0,0 +1,378 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema recordsArrayMap0; + private final Schema recordsArrayMapArrayElemSchema0; + private final Schema recordsArrayMapElemMapValueSchema0; + private final Schema recordsArrayMapElemValueOptionSchema0; + private final Schema subField0; + private final Schema recordsMapArray0; + private final Schema recordsMapArrayMapValueSchema0; + private final Schema recordsMapArrayValueArrayElemSchema0; + private final Schema recordsArrayMapUnion0; + private final Schema recordsArrayMapUnionOptionArrayElemSchema0; + private final Schema recordsArrayMapUnionOptionElemMapValueSchema0; + private final Schema recordsMapArrayUnion0; + private final Schema recordsMapArrayUnionOptionSchema0; + private final Schema recordsMapArrayUnionOptionValueArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordsArrayMap0 = readerSchema.getField("recordsArrayMap").schema(); + this.recordsArrayMapArrayElemSchema0 = recordsArrayMap0 .getElementType(); + this.recordsArrayMapElemMapValueSchema0 = recordsArrayMapArrayElemSchema0 .getValueType(); + this.recordsArrayMapElemValueOptionSchema0 = recordsArrayMapElemMapValueSchema0 .getTypes().get(1); + this.subField0 = recordsArrayMapElemValueOptionSchema0 .getField("subField").schema(); + this.recordsMapArray0 = readerSchema.getField("recordsMapArray").schema(); + this.recordsMapArrayMapValueSchema0 = recordsMapArray0 .getValueType(); + this.recordsMapArrayValueArrayElemSchema0 = recordsMapArrayMapValueSchema0 .getElementType(); + this.recordsArrayMapUnion0 = readerSchema.getField("recordsArrayMapUnion").schema(); + this.recordsArrayMapUnionOptionArrayElemSchema0 = recordsArrayMap0 .getElementType(); + this.recordsArrayMapUnionOptionElemMapValueSchema0 = recordsArrayMapUnionOptionArrayElemSchema0 .getValueType(); + this.recordsMapArrayUnion0 = readerSchema.getField("recordsMapArrayUnion").schema(); + this.recordsMapArrayUnionOptionSchema0 = recordsMapArrayUnion0 .getTypes().get(1); + this.recordsMapArrayUnionOptionValueArrayElemSchema0 = recordsMapArrayMapValueSchema0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List> recordsArrayMap1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(0); + if (oldArray0 instanceof List) { + recordsArrayMap1 = ((List) oldArray0); + recordsArrayMap1 .clear(); + } else { + recordsArrayMap1 = new org.apache.avro.generic.GenericData.Array>(((int) chunkLen0), recordsArrayMap0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 recordsArrayMapElem0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen1))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap1 .add(recordsArrayMapElem0); + } + chunkLen0 = (decoder.arrayNext()); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(0, recordsArrayMap1); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordsArrayMapElemValueOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(recordsArrayMapElemValueOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray1 = null; + long chunkLen2 = (decoder.readMapStart()); + if (chunkLen2 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), ((int) chunkLen2))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap0); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray1 = recordsMapArrayReuse0; + } else { + recordsMapArray1 = new HashMap>(((int)(((chunkLen2 * 4)+ 2)/ 3))); + } + } + do { + for (int counter2 = 0; (counter2 recordsMapArrayValue0 = null; + long chunkLen3 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen3), recordsMapArrayMapValueSchema0); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), 0)); + } else { + recordsMapArray1 = new HashMap>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(1, recordsMapArray1); + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(2, null); + } else { + if (unionIndex3 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(2); + if (oldArray1 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray1); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new org.apache.avro.generic.GenericData.Array>(((int) chunkLen4), recordsArrayMap0); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArrayMapUnionOptionElem0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen5))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen4 = (decoder.arrayNext()); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(2, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex3)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(3, null); + } else { + if (unionIndex5 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), ((int) chunkLen6))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 recordsMapArrayUnionOptionValue0 = null; + long chunkLen7 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen7), recordsMapArrayMapValueSchema0); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(3, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex5)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java new file mode 100644 index 000000000..95d0433fe --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java @@ -0,0 +1,114 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema record0; + private final Schema recordOptionSchema0; + private final Schema subField0; + private final Schema field0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record0 = readerSchema.getField("record").schema(); + this.recordOptionSchema0 = record0 .getTypes().get(1); + this.subField0 = recordOptionSchema0 .getField("subField").schema(); + this.field0 = readerSchema.getField("field").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'record': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(recordOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(1), (decoder), (customization))); + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(2, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(2); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(2, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex2)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java new file mode 100644 index 000000000..135649e7a --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java @@ -0,0 +1,252 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testNotRemoved0; + private final Schema testNotRemoved20; + private final Schema subRecord0; + private final Schema subRecordOptionSchema0; + private final Schema testNotRemoved1; + private final Schema testNotRemoved21; + private final Schema subRecordMap0; + private final Schema subRecordArray0; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testNotRemoved0 = readerSchema.getField("testNotRemoved").schema(); + this.testNotRemoved20 = readerSchema.getField("testNotRemoved2").schema(); + this.subRecord0 = readerSchema.getField("subRecord").schema(); + this.subRecordOptionSchema0 = subRecord0 .getTypes().get(1); + this.testNotRemoved1 = subRecordOptionSchema0 .getField("testNotRemoved").schema(); + this.testNotRemoved21 = subRecordOptionSchema0 .getField("testNotRemoved2").schema(); + this.subRecordMap0 = readerSchema.getField("subRecordMap").schema(); + this.subRecordArray0 = readerSchema.getField("subRecordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + } else { + if (unionIndex1 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testRemoved': "+ unionIndex1)); + } + } + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(1, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved2': "+ unionIndex2)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, null); + } else { + if (unionIndex3 == 1) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(2), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex3)); + } + } + Map subRecordMap1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), ((int) chunkLen0))); + } else { + Map subRecordMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3); + if (oldMap0 instanceof Map) { + subRecordMapReuse0 = ((Map) oldMap0); + } + if (subRecordMapReuse0 != (null)) { + subRecordMapReuse0 .clear(); + subRecordMap1 = subRecordMapReuse0; + } else { + subRecordMap1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), 0)); + } else { + subRecordMap1 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(3, subRecordMap1); + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecordOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecordOptionSchema0); + } + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex4 == 1) { + Utf8 charSequence2; + Object oldString2 = subRecord.get(0); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + subRecord.put(0, charSequence2); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex4)); + } + } + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + } else { + if (unionIndex5 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testRemoved': "+ unionIndex5)); + } + } + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + subRecord.put(1, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence3; + Object oldString3 = subRecord.get(1); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + subRecord.put(1, charSequence3); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved2': "+ unionIndex6)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List subRecordArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(4); + if (oldArray0 instanceof List) { + subRecordArray1 = ((List) oldArray0); + subRecordArray1 .clear(); + } else { + subRecordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), subRecordArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema subRecord0; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord_GenericDeserializer_1090641932_438987109(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.get(0), (decoder), (customization))); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord0); + } + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + populate_subRecord0((subRecord), (customization), (decoder)); + populate_subRecord1((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubSubRecord0(null, (decoder), (customization)); + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + deserializesubSubRecord0(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'test3': "+ unionIndex0)); + } + } + } + + public void deserializesubSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + populate_subSubRecord0((decoder)); + } + + private void populate_subSubRecord0(Decoder decoder) + throws IOException + { + decoder.skipString(); + } + + private void populate_subRecord1(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = subRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + subRecord.put(1, charSequence1); + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java new file mode 100644 index 000000000..0878f0b4f --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java @@ -0,0 +1,114 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema subRecord10; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord10 = readerSchema.getField("subRecord1").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord10)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord10); + } + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = subRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + subRecord.put(1, charSequence1); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubRecord20(null, (decoder), (customization)); + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + deserializesubRecord20(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord3': "+ unionIndex0)); + } + } + } + + public void deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + populate_subRecord20((decoder)); + } + + private void populate_subRecord20(Decoder decoder) + throws IOException + { + decoder.skipString(); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(1), (decoder), (customization))); + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java new file mode 100644 index 000000000..a4fb5ed7e --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java @@ -0,0 +1,60 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java new file mode 100644 index 000000000..4bd9586a0 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java @@ -0,0 +1,60 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java new file mode 100644 index 000000000..faf70c881 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + throw new AvroTypeException("Found \"long\", expecting [\"null\", \"string\"]"); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java new file mode 100644 index 000000000..69209d084 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java new file mode 100644 index 000000000..50bf210aa --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java new file mode 100644 index 000000000..f75194392 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java new file mode 100644 index 000000000..8473eb6ae --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java new file mode 100644 index 000000000..9a8c9d8d3 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java new file mode 100644 index 000000000..a9d77aa98 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java @@ -0,0 +1,71 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_906204958(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_1778260273(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.put(0, null); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_906204958(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.put(0, null); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_2127585735(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + if (unionIndex0 == 1) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java new file mode 100644 index 000000000..79eb49e4b --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + if (unionIndex0 == 1) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java new file mode 100644 index 000000000..ea955890a --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + if (unionIndex0 == 1) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java new file mode 100644 index 000000000..8d2655fd9 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + if (unionIndex0 == 1) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java new file mode 100644 index 000000000..2b789790d --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java new file mode 100644 index 000000000..c813e3334 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java new file mode 100644 index 000000000..712f62a03 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java new file mode 100644 index 000000000..8b1c0455c --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java new file mode 100644 index 000000000..e905639fb --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + this.testOptionSchema1 = test0 .getTypes().get(2); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java new file mode 100644 index 000000000..6e444a0ad --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + this.testOptionSchema1 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java new file mode 100644 index 000000000..822c8fc1a --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(2); + this.testOptionSchema1 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java new file mode 100644 index 000000000..25c61119a --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + this.testOptionSchema1 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java new file mode 100644 index 000000000..6dbcf5136 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java @@ -0,0 +1,148 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyInReaderSchemaTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyInReaderSchemaTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence1; + Object oldString1 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + testStringArray1 .clear(); + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java new file mode 100644 index 000000000..6a2244e4a --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java @@ -0,0 +1,130 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyInReaderSchemaTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyInReaderSchemaTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + String charSequence0 = (decoder).readString(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, null); + } else { + if (unionIndex0 == 1) { + String charSequence1 = (decoder).readString(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + testStringArray1 .clear(); + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java new file mode 100644 index 000000000..38b94d387 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java @@ -0,0 +1,130 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + String charSequence0 = (decoder).readString(); + FastStringableTest_javaStringPropertyTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyTest0((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyTest1((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyTest; + } + + private void populate_FastStringableTest_javaStringPropertyTest0(IndexedRecord FastStringableTest_javaStringPropertyTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyTest.put(1, null); + } else { + if (unionIndex0 == 1) { + String charSequence1 = (decoder).readString(); + FastStringableTest_javaStringPropertyTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + testStringArray1 .clear(); + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java new file mode 100644 index 000000000..97c0581c8 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java @@ -0,0 +1,1071 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex7 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex7)); + } + } + List testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema mapMapValueSchema0; + private final Schema mapValueOptionSchema0; + private final Schema field0; + + public Map_of_UNION_GenericDeserializer_2140000109_2140000109(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapValueSchema0 = readerSchema.getValueType(); + this.mapValueOptionSchema0 = mapMapValueSchema0 .getTypes().get(1); + this.field0 = mapValueOptionSchema0 .getField("field").schema(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapValueOptionSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapValueOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + record.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = record.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + record.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex1)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/Map_of_UNION_SpecificDeserializer_971650236_971650236.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/Map_of_UNION_SpecificDeserializer_971650236_971650236.java new file mode 100644 index 000000000..9a00cd7d7 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/Map_of_UNION_SpecificDeserializer_971650236_971650236.java @@ -0,0 +1,1081 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_UNION_SpecificDeserializer_971650236_971650236 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Map_of_UNION_SpecificDeserializer_971650236_971650236(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex1)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex2)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex3)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex4)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex5 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex5)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex6 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex6)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex7 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex7)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + List testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex15 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex17)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex21 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex21)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex23 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex23)); + } + } + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex25 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex25 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex25 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex25)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema unionOptionMapValueSchema0; + + public Map_of_record_GenericDeserializer_1223705675_568621313(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOptionMapValueSchema0 = readerSchema.getValueType(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":{\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}}"); + } else { + if (unionIndex0 == 1) { + Map unionOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map unionOptionReuse0 = null; + if ((reuse) instanceof Map) { + unionOptionReuse0 = ((Map)(reuse)); + } + if (unionOptionReuse0 != (null)) { + unionOptionReuse0 .clear(); + unionOption0 = unionOptionReuse0; + } else { + unionOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + unionOption0 = new HashMap(0); + } + } + return unionOption0; + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == unionOptionMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(unionOptionMapValueSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/Map_of_record_GenericDeserializer_1677529043_1677529043.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/Map_of_record_GenericDeserializer_1677529043_1677529043.java new file mode 100644 index 000000000..29a6a0a9b --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/Map_of_record_GenericDeserializer_1677529043_1677529043.java @@ -0,0 +1,95 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_record_GenericDeserializer_1677529043_1677529043 + implements FastDeserializer> +{ + + private final Schema readerSchema; + private final Schema mapMapValueSchema0; + private final Schema field0; + + public Map_of_record_GenericDeserializer_1677529043_1677529043(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapValueSchema0 = readerSchema.getValueType(); + this.field0 = mapMapValueSchema0 .getField("field").schema(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapMapValueSchema0); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + record.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = record.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + record.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java new file mode 100644 index 000000000..18dd68702 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java @@ -0,0 +1,61 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserialize(com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRecordWithLargeUnionField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserializeRecordWithLargeUnionField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField RecordWithLargeUnionField; + if ((reuse)!= null) { + RecordWithLargeUnionField = ((com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField)(reuse)); + } else { + RecordWithLargeUnionField = new com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Utf8 charSequence0; + Object oldString0 = RecordWithLargeUnionField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RecordWithLargeUnionField.put(0, charSequence0); + } else { + if (unionIndex0 == 1) { + RecordWithLargeUnionField.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + throw new AvroTypeException(new StringBuilder().append("Found").append(" \"byt").append("es\", ").append("expec").append("ting ").append("[\"str").append("ing\",").append(" \"int").append("\"]").toString()); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + } + return RecordWithLargeUnionField; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java new file mode 100644 index 000000000..e9572a549 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java @@ -0,0 +1,47 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; + if ((reuse)!= null) { + RemovedTypesTestRecord = ((com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord)(reuse)); + } else { + RemovedTypesTestRecord = new com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord(); + } + Utf8 charSequence0; + Object oldString0 = RemovedTypesTestRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RemovedTypesTestRecord.put(0, charSequence0); + return RemovedTypesTestRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java new file mode 100644 index 000000000..425f936f1 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java @@ -0,0 +1,406 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; + if ((reuse)!= null) { + RemovedTypesTestRecord = ((com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord)(reuse)); + } else { + RemovedTypesTestRecord = new com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord(); + } + Utf8 charSequence0; + Object oldString0 = RemovedTypesTestRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RemovedTypesTestRecord.put(0, charSequence0); + populate_RemovedTypesTestRecord0((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord1((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord2((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord3((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord4((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord5((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord6((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord7((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord8((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord9((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord10((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord11((RemovedTypesTestRecord), (customization), (decoder)); + return RemovedTypesTestRecord; + } + + private void populate_RemovedTypesTestRecord0(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.skipBytes(); + long chunkLen0 = (decoder.readArrayStart()); + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 0) { + do { + for (int counter1 = 0; (counter1 0); + } + } + + private void populate_RemovedTypesTestRecord2(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen2 = (decoder.readArrayStart()); + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 0) { + do { + for (int counter3 = 0; (counter3 0); + } + } + + private void populate_RemovedTypesTestRecord3(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.skipFixed(1); + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + } else { + if (unionIndex3 == 1) { + decoder.skipFixed(1); + } else { + throw new RuntimeException(("Illegal union index for 'removedFixedUnion': "+ unionIndex3)); + } + } + } + + private void populate_RemovedTypesTestRecord4(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen4 = (decoder.readArrayStart()); + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 0) { + do { + for (int counter5 = 0; (counter5 0); + } + } + + private void populate_RemovedTypesTestRecord5(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen6 = (decoder.readArrayStart()); + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 0) { + do { + for (int counter7 = 0; (counter7 0); + } + } + + private void populate_RemovedTypesTestRecord6(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.readEnum(); + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + } else { + if (unionIndex6 == 1) { + decoder.readEnum(); + } else { + throw new RuntimeException(("Illegal union index for 'removedEnumUnion': "+ unionIndex6)); + } + } + } + + private void populate_RemovedTypesTestRecord7(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen8 = (decoder.readArrayStart()); + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 0) { + do { + for (int counter9 = 0; (counter9 0); + } + } + + private void populate_RemovedTypesTestRecord8(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen10 = (decoder.readArrayStart()); + while (chunkLen10 > 0) { + for (int counter10 = 0; (counter10 0) { + do { + for (int counter11 = 0; (counter11 0); + } + } + + private void populate_RemovedTypesTestRecord9(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializeRemovedSubRecord0(null, (decoder), (customization)); + int unionIndex9 = (decoder.readIndex()); + if (unionIndex9 == 0) { + decoder.readNull(); + } else { + if (unionIndex9 == 1) { + deserializeRemovedSubRecord0(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'removedSubRecordUnion': "+ unionIndex9)); + } + } + } + + public void deserializeRemovedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + } + + private void populate_RemovedTypesTestRecord10(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen12 = (decoder.readArrayStart()); + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0) { + for (int counter13 = 0; (counter13 0) { + do { + for (int counter14 = 0; (counter14 0); + } + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + do { + for (int counter15 = 0; (counter15 0); + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java new file mode 100644 index 000000000..fed5a4f5b --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java @@ -0,0 +1,172 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class SplitRecordTest1_SpecificDeserializer_1718878379_595582209 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public SplitRecordTest1_SpecificDeserializer_1718878379_595582209(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeSplitRecordTest10((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserializeSplitRecordTest10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 SplitRecordTest1; + if ((reuse)!= null) { + SplitRecordTest1 = ((com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1)(reuse)); + } else { + SplitRecordTest1 = new com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1(); + } + SplitRecordTest1 .put(0, deserializeFullRecord0(SplitRecordTest1 .get(0), (decoder), (customization))); + populate_SplitRecordTest10((SplitRecordTest1), (customization), (decoder)); + return SplitRecordTest1; + } + + public com.linkedin.avro.fastserde.generated.avro.FullRecord deserializeFullRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.FullRecord FullRecord; + if ((reuse)!= null) { + FullRecord = ((com.linkedin.avro.fastserde.generated.avro.FullRecord)(reuse)); + } else { + FullRecord = new com.linkedin.avro.fastserde.generated.avro.FullRecord(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FullRecord.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FullRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FullRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex0)); + } + } + FullRecord.put(1, null); + return FullRecord; + } + + private void populate_SplitRecordTest10(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 SplitRecordTest1, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + SplitRecordTest1 .put(1, deserializeFullRecord1(SplitRecordTest1 .get(1), (decoder), (customization))); + List record30 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = SplitRecordTest1 .get(2); + if (oldArray0 instanceof List) { + record30 = ((List) oldArray0); + record30 .clear(); + } else { + record30 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public SplitRecordTest2_SpecificDeserializer_595582209_1718878379(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeSplitRecordTest20((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserializeSplitRecordTest20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 SplitRecordTest2; + if ((reuse)!= null) { + SplitRecordTest2 = ((com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2)(reuse)); + } else { + SplitRecordTest2 = new com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2(); + } + SplitRecordTest2 .put(0, deserializeStringRecord0(SplitRecordTest2 .get(0), (decoder), (customization))); + populate_SplitRecordTest20((SplitRecordTest2), (customization), (decoder)); + return SplitRecordTest2; + } + + public StringRecord deserializeStringRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + StringRecord IntRecord; + if ((reuse)!= null) { + IntRecord = ((StringRecord)(reuse)); + } else { + IntRecord = new StringRecord(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + IntRecord.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = IntRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + IntRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex0)); + } + } + populate_IntRecord0((IntRecord), (customization), (decoder)); + return IntRecord; + } + + private void populate_IntRecord0(StringRecord IntRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + } else { + if (unionIndex1 == 1) { + decoder.readInt(); + } else { + throw new RuntimeException(("Illegal union index for 'field2': "+ unionIndex1)); + } + } + } + + private void populate_SplitRecordTest20(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 SplitRecordTest2, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + SplitRecordTest2 .put(1, deserializeIntRecord0(SplitRecordTest2 .get(1), (decoder), (customization))); + List record30 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = SplitRecordTest2 .get(2); + if (oldArray0 instanceof List) { + record30 = ((List) oldArray0); + record30 .clear(); + } else { + record30 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public StringableRecord_SpecificDeserializer_842267318_842267318(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserialize(com.linkedin.avro.fastserde.generated.avro.StringableRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + try { + return deserializeStringableRecord0((reuse), (decoder), (customization)); + } catch (NumberFormatException e) { + throw new AvroRuntimeException(e); + } catch (MalformedURLException e) { + throw new AvroRuntimeException(e); + } catch (URISyntaxException e) { + throw new AvroRuntimeException(e); + } + } + + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserializeStringableRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord; + if ((reuse)!= null) { + StringableRecord = ((com.linkedin.avro.fastserde.generated.avro.StringableRecord)(reuse)); + } else { + StringableRecord = new com.linkedin.avro.fastserde.generated.avro.StringableRecord(); + } + BigInteger charSequence0 = new BigInteger((decoder.readString())); + StringableRecord.put(0, charSequence0); + populate_StringableRecord0((StringableRecord), (customization), (decoder)); + populate_StringableRecord1((StringableRecord), (customization), (decoder)); + populate_StringableRecord2((StringableRecord), (customization), (decoder)); + populate_StringableRecord3((StringableRecord), (customization), (decoder)); + populate_StringableRecord4((StringableRecord), (customization), (decoder)); + return StringableRecord; + } + + private void populate_StringableRecord0(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, URISyntaxException + { + BigDecimal charSequence1 = new BigDecimal((decoder.readString())); + StringableRecord.put(1, charSequence1); + URI charSequence2 = new URI((decoder.readString())); + StringableRecord.put(2, charSequence2); + } + + private void populate_StringableRecord1(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + URL charSequence3 = new URL((decoder.readString())); + StringableRecord.put(3, charSequence3); + File charSequence4 = new File((decoder.readString())); + StringableRecord.put(4, charSequence4); + } + + private void populate_StringableRecord2(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + List urlArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = StringableRecord.get(5); + if (oldArray0 instanceof List) { + urlArray0 = ((List) oldArray0); + urlArray0 .clear(); + } else { + urlArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 urlMap0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), ((int) chunkLen1))); + } else { + Map urlMapReuse0 = null; + Object oldMap0 = StringableRecord.get(6); + if (oldMap0 instanceof Map) { + urlMapReuse0 = ((Map) oldMap0); + } + if (urlMapReuse0 != (null)) { + urlMapReuse0 .clear(); + urlMap0 = urlMapReuse0; + } else { + urlMap0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), 0)); + } else { + urlMap0 = new HashMap(0); + } + } + StringableRecord.put(6, urlMap0); + } + + private void populate_StringableRecord3(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + StringableRecord.put(7, deserializeStringableSubRecord0(StringableRecord.get(7), (decoder), (customization))); + StringableRecord.put(8, deserializeAnotherSubRecord0(StringableRecord.get(8), (decoder), (customization))); + } + + public com.linkedin.avro.fastserde.generated.avro.StringableSubRecord deserializeStringableSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException, URISyntaxException + { + com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord; + if ((reuse)!= null) { + StringableSubRecord = ((com.linkedin.avro.fastserde.generated.avro.StringableSubRecord)(reuse)); + } else { + StringableSubRecord = new com.linkedin.avro.fastserde.generated.avro.StringableSubRecord(); + } + URI charSequence7 = new URI((decoder.readString())); + StringableSubRecord.put(0, charSequence7); + populate_StringableSubRecord0((StringableSubRecord), (customization), (decoder)); + return StringableSubRecord; + } + + private void populate_StringableSubRecord0(com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, URISyntaxException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + StringableSubRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence8; + Object oldString0 = StringableSubRecord.get(1); + if (oldString0 instanceof Utf8) { + charSequence8 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence8 = (decoder).readString(null); + } + StringableSubRecord.put(1, charSequence8); + } else { + if (unionIndex0 == 2) { + StringableSubRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'nullStringIntUnion': "+ unionIndex0)); + } + } + } + } + + public com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord deserializeAnotherSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException, URISyntaxException + { + com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord AnotherSubRecord; + if ((reuse)!= null) { + AnotherSubRecord = ((com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord)(reuse)); + } else { + AnotherSubRecord = new com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord(); + } + AnotherSubRecord.put(0, deserializeStringableSubRecord0(AnotherSubRecord.get(0), (decoder), (customization))); + return AnotherSubRecord; + } + + private void populate_StringableRecord4(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + StringableRecord.put(9, null); + } else { + if (unionIndex1 == 1) { + String charSequence9 = (decoder).readString(); + StringableRecord.put(9, charSequence9); + } else { + throw new RuntimeException(("Illegal union index for 'stringUnion': "+ unionIndex1)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java new file mode 100644 index 000000000..be7f0242e --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java @@ -0,0 +1,46 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class TestArrayOfFloats_GenericDeserializer_1408566797_1408566797 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema array_of_float0; + + public TestArrayOfFloats_GenericDeserializer_1408566797_1408566797(Schema readerSchema) { + this.readerSchema = readerSchema; + this.array_of_float0 = readerSchema.getField("array_of_float").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestArrayOfFloats0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestArrayOfFloats0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord TestArrayOfFloats; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + TestArrayOfFloats = ((IndexedRecord)(reuse)); + } else { + TestArrayOfFloats = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + PrimitiveFloatList array_of_float1 = null; + array_of_float1 = ((PrimitiveFloatList) BufferBackedPrimitiveFloatList.readPrimitiveFloatArray(TestArrayOfFloats.get(0), (decoder))); + TestArrayOfFloats.put(0, array_of_float1); + return TestArrayOfFloats; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/TestRecord_GenericDeserializer_473555078_473555078.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/TestRecord_GenericDeserializer_473555078_473555078.java new file mode 100644 index 000000000..6148a234a --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/TestRecord_GenericDeserializer_473555078_473555078.java @@ -0,0 +1,78 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_GenericDeserializer_473555078_473555078 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema map_field0; + + public TestRecord_GenericDeserializer_473555078_473555078(Schema readerSchema) { + this.readerSchema = readerSchema; + this.map_field0 = readerSchema.getField("map_field").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord TestRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + TestRecord = ((IndexedRecord)(reuse)); + } else { + TestRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map map_field1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), ((int) chunkLen0))); + } else { + Map map_fieldReuse0 = null; + Object oldMap0 = TestRecord.get(0); + if (oldMap0 instanceof Map) { + map_fieldReuse0 = ((Map) oldMap0); + } + if (map_fieldReuse0 != (null)) { + map_fieldReuse0 .clear(); + map_field1 = map_fieldReuse0; + } else { + map_field1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), 0)); + } else { + map_field1 = new HashMap(0); + } + } + TestRecord.put(0, map_field1); + return TestRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/TestRecord_SpecificDeserializer_1898726132_553331077.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/TestRecord_SpecificDeserializer_1898726132_553331077.java new file mode 100644 index 000000000..9d61fbd11 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/TestRecord_SpecificDeserializer_1898726132_553331077.java @@ -0,0 +1,1039 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_1898726132_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Map enumMappingTestEnum0; + private final Map enumMappingTestEnum1; + private final Map enumMappingTestEnum2; + private final Map enumMappingTestEnum3; + + public TestRecord_SpecificDeserializer_1898726132_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + HashMap tempEnumMapping0 = new HashMap(5); + tempEnumMapping0 .put(new Integer(0), new Integer(4)); + tempEnumMapping0 .put(new Integer(1), new Integer(3)); + tempEnumMapping0 .put(new Integer(2), new Integer(1)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + HashMap tempEnumMapping1 = new HashMap(5); + tempEnumMapping1 .put(new Integer(0), new Integer(4)); + tempEnumMapping1 .put(new Integer(1), new Integer(3)); + tempEnumMapping1 .put(new Integer(2), new Integer(1)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + HashMap tempEnumMapping2 = new HashMap(5); + tempEnumMapping2 .put(new Integer(0), new Integer(4)); + tempEnumMapping2 .put(new Integer(1), new Integer(3)); + tempEnumMapping2 .put(new Integer(2), new Integer(1)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + HashMap tempEnumMapping3 = new HashMap(5); + tempEnumMapping3 .put(new Integer(0), new Integer(4)); + tempEnumMapping3 .put(new Integer(1), new Integer(3)); + tempEnumMapping3 .put(new Integer(2), new Integer(1)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + ArrayList defaultArray0 = new ArrayList(); + TestRecord.put(33, defaultArray0); + ArrayList defaultArray1 = new ArrayList(); + TestRecord.put(34, defaultArray1); + ArrayList defaultArray2 = new ArrayList(); + TestRecord.put(35, defaultArray2); + ArrayList defaultArray3 = new ArrayList(); + TestRecord.put(36, defaultArray3); + ArrayList defaultArray4 = new ArrayList(); + TestRecord.put(37, defaultArray4); + ArrayList defaultArray5 = new ArrayList(); + TestRecord.put(38, defaultArray5); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + } else { + if (unionIndex7 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'removedField': "+ unionIndex7)); + } + } + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + } + + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + } + + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex16 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex18)); + } + } + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex22 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex24 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex24)); + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex26 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex26 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex26 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex26)); + } + } + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/TestRecord_SpecificDeserializer_1991094399_553331077.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/TestRecord_SpecificDeserializer_1991094399_553331077.java new file mode 100644 index 000000000..7b014013b --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/TestRecord_SpecificDeserializer_1991094399_553331077.java @@ -0,0 +1,1043 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_1991094399_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Map enumMappingTestEnum0; + private final Map enumMappingTestEnum1; + private final Map enumMappingTestEnum2; + private final Map enumMappingTestEnum3; + + public TestRecord_SpecificDeserializer_1991094399_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + HashMap tempEnumMapping0 = new HashMap(6); + tempEnumMapping0 .put(new Integer(0), new Integer(4)); + tempEnumMapping0 .put(new Integer(1), new Integer(3)); + tempEnumMapping0 .put(new Integer(2), new Integer(1)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(0)); + tempEnumMapping0 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + HashMap tempEnumMapping1 = new HashMap(6); + tempEnumMapping1 .put(new Integer(0), new Integer(4)); + tempEnumMapping1 .put(new Integer(1), new Integer(3)); + tempEnumMapping1 .put(new Integer(2), new Integer(1)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(0)); + tempEnumMapping1 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + HashMap tempEnumMapping2 = new HashMap(6); + tempEnumMapping2 .put(new Integer(0), new Integer(4)); + tempEnumMapping2 .put(new Integer(1), new Integer(3)); + tempEnumMapping2 .put(new Integer(2), new Integer(1)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(0)); + tempEnumMapping2 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + HashMap tempEnumMapping3 = new HashMap(6); + tempEnumMapping3 .put(new Integer(0), new Integer(4)); + tempEnumMapping3 .put(new Integer(1), new Integer(3)); + tempEnumMapping3 .put(new Integer(2), new Integer(1)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(0)); + tempEnumMapping3 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + ArrayList defaultArray0 = new ArrayList(); + TestRecord.put(33, defaultArray0); + ArrayList defaultArray1 = new ArrayList(); + TestRecord.put(34, defaultArray1); + ArrayList defaultArray2 = new ArrayList(); + TestRecord.put(35, defaultArray2); + ArrayList defaultArray3 = new ArrayList(); + TestRecord.put(36, defaultArray3); + ArrayList defaultArray4 = new ArrayList(); + TestRecord.put(37, defaultArray4); + ArrayList defaultArray5 = new ArrayList(); + TestRecord.put(38, defaultArray5); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + } else { + if (unionIndex7 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'removedField': "+ unionIndex7)); + } + } + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + } + + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + } + + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex16 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex18)); + } + } + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex22 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex24 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex24)); + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex26 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex26 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex26 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex26)); + } + } + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/TestRecord_SpecificDeserializer_553331077_553331077.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/TestRecord_SpecificDeserializer_553331077_553331077.java new file mode 100644 index 000000000..00c99b78b --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/TestRecord_SpecificDeserializer_553331077_553331077.java @@ -0,0 +1,1040 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_553331077_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public TestRecord_SpecificDeserializer_553331077_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex7 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex7)); + } + } + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen16 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 stringArray0 = null; + long chunkLen20 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen20)); + } + while (chunkLen20 > 0) { + for (int counter20 = 0; (counter20 +{ + + private final Schema readerSchema; + private final Schema recordRecordSchema0; + + public UNION_GenericDeserializer_1971822364_1672473580(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordRecordSchema0 = readerSchema.getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordRecordSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(recordRecordSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/UNION_GenericDeserializer_2018567528_1606337179.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/UNION_GenericDeserializer_2018567528_1606337179.java new file mode 100644 index 000000000..d1056f029 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/UNION_GenericDeserializer_2018567528_1606337179.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class UNION_GenericDeserializer_2018567528_1606337179 + implements FastDeserializer> +{ + + private final Schema readerSchema; + private final Schema arrayArraySchema0; + private final Schema arrayArrayElemSchema0; + + public UNION_GenericDeserializer_2018567528_1606337179(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArraySchema0 = readerSchema.getTypes().get(1); + this.arrayArrayElemSchema0 = arrayArraySchema0 .getElementType(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), arrayArraySchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + private final Schema mapMapSchema0; + private final Schema mapMapValueSchema0; + + public UNION_GenericDeserializer_568621313_1223705675(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapSchema0 = readerSchema.getTypes().get(1); + this.mapMapValueSchema0 = mapMapSchema0 .getValueType(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapMapValueSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java new file mode 100644 index 000000000..c4ccd5c18 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.MyEnumV1; +import com.linkedin.avro.fastserde.generated.avro.MyEnumV2; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserialize(com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeUnionOfRecordsWithSameNameEnumField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserializeUnionOfRecordsWithSameNameEnumField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField UnionOfRecordsWithSameNameEnumField; + if ((reuse)!= null) { + UnionOfRecordsWithSameNameEnumField = ((com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField)(reuse)); + } else { + UnionOfRecordsWithSameNameEnumField = new com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV10(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV20(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + return UnionOfRecordsWithSameNameEnumField; + } + + public com.linkedin.avro.fastserde.generated.avro.MyRecordV1 deserializeMyRecordV10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.MyRecordV1 MyRecordV1; + if ((reuse)!= null) { + MyRecordV1 = ((com.linkedin.avro.fastserde.generated.avro.MyRecordV1)(reuse)); + } else { + MyRecordV1 = new com.linkedin.avro.fastserde.generated.avro.MyRecordV1(); + } + MyRecordV1 .put(0, Enums.getConstant(MyEnumV1 .class, (decoder.readEnum()))); + return MyRecordV1; + } + + public com.linkedin.avro.fastserde.generated.avro.MyRecordV2 deserializeMyRecordV20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.MyRecordV2 MyRecordV2; + if ((reuse)!= null) { + MyRecordV2 = ((com.linkedin.avro.fastserde.generated.avro.MyRecordV2)(reuse)); + } else { + MyRecordV2 = new com.linkedin.avro.fastserde.generated.avro.MyRecordV2(); + } + MyRecordV2 .put(0, Enums.getConstant(MyEnumV2 .class, (decoder.readEnum()))); + return MyRecordV2; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/recordName_GenericDeserializer_1743054079_1743054079.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/recordName_GenericDeserializer_1743054079_1743054079.java new file mode 100644 index 000000000..f399229a4 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/recordName_GenericDeserializer_1743054079_1743054079.java @@ -0,0 +1,67 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class recordName_GenericDeserializer_1743054079_1743054079 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema unionField0; + + public recordName_GenericDeserializer_1743054079_1743054079(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionField0 = readerSchema.getField("unionField").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecordName0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecordName0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord recordName; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + recordName = ((IndexedRecord)(reuse)); + } else { + recordName = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = recordName.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + recordName.put(0, charSequence0); + populate_recordName0((recordName), (customization), (decoder)); + return recordName; + } + + private void populate_recordName0(IndexedRecord recordName, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + recordName.put(1, null); + } else { + if (unionIndex0 == 1) { + recordName.put(1, deserializerecordName0(recordName.get(1), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1025741720_1557256887.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1025741720_1557256887.java new file mode 100644 index 000000000..21597eb41 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1025741720_1557256887.java @@ -0,0 +1,96 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1025741720_1557256887 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_1025741720_1557256887(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + Map someIntsOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } + } + record.put(0, someIntsOption0); + } else { + throw new RuntimeException(("Illegal union index for 'someInts': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1126840752_2099305627.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1126840752_2099305627.java new file mode 100644 index 000000000..3837b697b --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1126840752_2099305627.java @@ -0,0 +1,50 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1126840752_2099305627 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1126840752_2099305627(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + record.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 1) { + throw new AvroTypeException("Found \"string\", expecting \"int\""); + } else { + throw new RuntimeException(("Illegal union index for 'someField': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1191367445_653449771.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1191367445_653449771.java new file mode 100644 index 000000000..f09bd5a9f --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1191367445_653449771.java @@ -0,0 +1,69 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1191367445_653449771 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_1191367445_653449771(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList someIntsOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someIntsOption0 = ((PrimitiveIntList) oldArray0); + someIntsOption0 .clear(); + } else { + someIntsOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1373882843_1971822364(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + record.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'someInt': "+ unionIndex0)); + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1556659421_711533897.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1556659421_711533897.java new file mode 100644 index 000000000..8db91532d --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1556659421_711533897.java @@ -0,0 +1,72 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1556659421_711533897 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema subRecord0; + + public record_GenericDeserializer_1556659421_711533897(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"subRecord\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"subRecord\",\"fields\":[{\"name\":\"someInt1\",\"type\":\"int\",\"doc\":\"\"},{\"name\":\"someInt2\",\"type\":\"int\",\"doc\":\"\"}]}"); + } else { + if (unionIndex0 == 1) { + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex0)); + } + } + return record; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord0); + } + subRecord.put(0, (decoder.readInt())); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + subRecord.put(1, (decoder.readInt())); + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1557256887_1025741720.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1557256887_1025741720.java new file mode 100644 index 000000000..d2903a2dd --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1557256887_1025741720.java @@ -0,0 +1,81 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1557256887_1025741720 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsMapSchema0; + private final Schema someIntsMapValueSchema0; + + public record_GenericDeserializer_1557256887_1025741720(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsMapSchema0 = someInts0 .getTypes().get(1); + this.someIntsMapValueSchema0 = someIntsMapSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map someInts1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } + } + record.put(0, someInts1); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1557256887_753570467.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1557256887_753570467.java new file mode 100644 index 000000000..0ea3e7414 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1557256887_753570467.java @@ -0,0 +1,79 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1557256887_753570467 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsMapSchema0; + + public record_GenericDeserializer_1557256887_753570467(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsMapSchema0 = someInts0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map someInts1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } + } + record.put(0, someInts1); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1672473580_1971822364.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1672473580_1971822364.java new file mode 100644 index 000000000..5e01ab095 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1672473580_1971822364.java @@ -0,0 +1,50 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1672473580_1971822364 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1672473580_1971822364(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}"); + } else { + if (unionIndex0 == 1) { + return deserializerecord0((reuse), (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1971822364_1373882843.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1971822364_1373882843.java new file mode 100644 index 000000000..21da87113 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_1971822364_1373882843.java @@ -0,0 +1,42 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1971822364_1373882843 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInt0; + + public record_GenericDeserializer_1971822364_1373882843(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInt0 = readerSchema.getField("someInt").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_653449771_1191367445.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_653449771_1191367445.java new file mode 100644 index 000000000..69e13b06a --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_653449771_1191367445.java @@ -0,0 +1,61 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_653449771_1191367445 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsArraySchema0; + + public record_GenericDeserializer_653449771_1191367445(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsArraySchema0 = someInts0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + PrimitiveIntList someInts1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someInts1 = ((PrimitiveIntList) oldArray0); + someInts1 .clear(); + } else { + someInts1 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsArraySchema0; + private final Schema someIntsArrayElemSchema0; + + public record_GenericDeserializer_653449771_813379571(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsArraySchema0 = someInts0 .getTypes().get(1); + this.someIntsArrayElemSchema0 = someIntsArraySchema0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List someInts1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof List) { + someInts1 = ((List) oldArray0); + someInts1 .clear(); + } else { + someInts1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), someIntsArraySchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema subRecord0; + private final Schema subRecordRecordSchema0; + + public record_GenericDeserializer_711533897_1556659421(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + this.subRecordRecordSchema0 = subRecord0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); + return record; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecordRecordSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecordRecordSchema0); + } + subRecord.put(0, (decoder.readInt())); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + subRecord.put(1, (decoder.readInt())); + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_753570467_1557256887.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_753570467_1557256887.java new file mode 100644 index 000000000..836ce66a0 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_753570467_1557256887.java @@ -0,0 +1,87 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_753570467_1557256887 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_753570467_1557256887(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + Map someIntsOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } + } + record.put(0, someIntsOption0); + } else { + throw new RuntimeException(("Illegal union index for 'someInts': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_813379571_653449771.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_813379571_653449771.java new file mode 100644 index 000000000..eab33f3b0 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_7/record_GenericDeserializer_813379571_653449771.java @@ -0,0 +1,83 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_813379571_653449771 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_813379571_653449771(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList someIntsOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someIntsOption0 = ((PrimitiveIntList) oldArray0); + someIntsOption0 .clear(); + } else { + someIntsOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + + public testRecord_GenericDeserializer_1146484089_1256982207(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(3); + tempEnumMapping0 .put(new Integer(0), new Integer(0)); + tempEnumMapping0 .put(new Integer(1), new Integer(1)); + tempEnumMapping0 .put(new Integer(2), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.testEnum: No match for C")); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializetestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializetestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord testRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + testRecord = ((IndexedRecord)(reuse)); + } else { + testRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + testRecord.put(0, enumValue0); + return testRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/Array_of_BOOLEAN_GenericSerializer_869749973.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/Array_of_BOOLEAN_GenericSerializer_869749973.java new file mode 100644 index 000000000..c7a0e4503 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/Array_of_BOOLEAN_GenericSerializer_869749973.java @@ -0,0 +1,41 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.io.Encoder; + +public class Array_of_BOOLEAN_GenericSerializer_869749973 + implements FastSerializer> +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveBooleanList) { + PrimitiveBooleanList primitiveList0 = ((PrimitiveBooleanList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveDoubleList) { + PrimitiveDoubleList primitiveList0 = ((PrimitiveDoubleList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveFloatList) { + PrimitiveFloatList primitiveList0 = ((PrimitiveFloatList) array0); + if (primitiveList0 instanceof BufferBackedPrimitiveFloatList) { + BufferBackedPrimitiveFloatList bufferBackedPrimitiveFloatList = ((BufferBackedPrimitiveFloatList) primitiveList0); + bufferBackedPrimitiveFloatList.writeFloats((encoder)); + } else { + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList0 = ((PrimitiveIntList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveLongList) { + PrimitiveLongList primitiveList0 = ((PrimitiveLongList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (int counter0 = 0; (counter0 ) data).get(counter0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/Array_of_record_GenericSerializer_477614132.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/Array_of_record_GenericSerializer_477614132.java new file mode 100644 index 000000000..52e447454 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/Array_of_record_GenericSerializer_477614132.java @@ -0,0 +1,53 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Array_of_record_GenericSerializer_477614132 + implements FastSerializer> +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (int counter0 = 0; (counter0 ) data).get(counter0); + serializeRecord0(record0, (encoder), (customization)); + } + } + (encoder).writeArrayEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java new file mode 100644 index 000000000..7ef4c8cfd --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java @@ -0,0 +1,4527 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(1))); + (encoder).writeInt(((Integer) data.get(2))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(3))); + (encoder).writeInt(((Integer) data.get(4))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(5))); + (encoder).writeInt(((Integer) data.get(6))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(7))); + (encoder).writeInt(((Integer) data.get(8))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(9))); + (encoder).writeInt(((Integer) data.get(10))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(11))); + (encoder).writeInt(((Integer) data.get(12))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(13))); + (encoder).writeInt(((Integer) data.get(14))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(15))); + (encoder).writeInt(((Integer) data.get(16))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(17))); + (encoder).writeInt(((Integer) data.get(18))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(19))); + (encoder).writeInt(((Integer) data.get(20))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(21))); + (encoder).writeInt(((Integer) data.get(22))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(23))); + (encoder).writeInt(((Integer) data.get(24))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(25))); + (encoder).writeInt(((Integer) data.get(26))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(27))); + (encoder).writeInt(((Integer) data.get(28))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(29))); + (encoder).writeInt(((Integer) data.get(30))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(31))); + (encoder).writeInt(((Integer) data.get(32))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(33))); + (encoder).writeInt(((Integer) data.get(34))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(35))); + (encoder).writeInt(((Integer) data.get(36))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(37))); + (encoder).writeInt(((Integer) data.get(38))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(39))); + (encoder).writeInt(((Integer) data.get(40))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(41))); + (encoder).writeInt(((Integer) data.get(42))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(43))); + (encoder).writeInt(((Integer) data.get(44))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(45))); + (encoder).writeInt(((Integer) data.get(46))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(47))); + (encoder).writeInt(((Integer) data.get(48))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(49))); + (encoder).writeInt(((Integer) data.get(50))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(51))); + (encoder).writeInt(((Integer) data.get(52))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(53))); + (encoder).writeInt(((Integer) data.get(54))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(55))); + (encoder).writeInt(((Integer) data.get(56))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(57))); + (encoder).writeInt(((Integer) data.get(58))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(59))); + (encoder).writeInt(((Integer) data.get(60))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(61))); + (encoder).writeInt(((Integer) data.get(62))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(63))); + (encoder).writeInt(((Integer) data.get(64))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(65))); + (encoder).writeInt(((Integer) data.get(66))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(67))); + (encoder).writeInt(((Integer) data.get(68))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(69))); + (encoder).writeInt(((Integer) data.get(70))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(71))); + (encoder).writeInt(((Integer) data.get(72))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(73))); + (encoder).writeInt(((Integer) data.get(74))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(75))); + (encoder).writeInt(((Integer) data.get(76))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(77))); + (encoder).writeInt(((Integer) data.get(78))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(79))); + (encoder).writeInt(((Integer) data.get(80))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(81))); + (encoder).writeInt(((Integer) data.get(82))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(83))); + (encoder).writeInt(((Integer) data.get(84))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(85))); + (encoder).writeInt(((Integer) data.get(86))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(87))); + (encoder).writeInt(((Integer) data.get(88))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(89))); + (encoder).writeInt(((Integer) data.get(90))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(91))); + (encoder).writeInt(((Integer) data.get(92))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(93))); + (encoder).writeInt(((Integer) data.get(94))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(95))); + (encoder).writeInt(((Integer) data.get(96))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(97))); + (encoder).writeInt(((Integer) data.get(98))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(99))); + (encoder).writeInt(((Integer) data.get(100))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(101))); + (encoder).writeInt(((Integer) data.get(102))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(103))); + (encoder).writeInt(((Integer) data.get(104))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(105))); + (encoder).writeInt(((Integer) data.get(106))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(107))); + (encoder).writeInt(((Integer) data.get(108))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(109))); + (encoder).writeInt(((Integer) data.get(110))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(111))); + (encoder).writeInt(((Integer) data.get(112))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(113))); + (encoder).writeInt(((Integer) data.get(114))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(115))); + (encoder).writeInt(((Integer) data.get(116))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(117))); + (encoder).writeInt(((Integer) data.get(118))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(119))); + (encoder).writeInt(((Integer) data.get(120))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(121))); + (encoder).writeInt(((Integer) data.get(122))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(123))); + (encoder).writeInt(((Integer) data.get(124))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(125))); + (encoder).writeInt(((Integer) data.get(126))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(127))); + (encoder).writeInt(((Integer) data.get(128))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(129))); + (encoder).writeInt(((Integer) data.get(130))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(131))); + (encoder).writeInt(((Integer) data.get(132))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(133))); + (encoder).writeInt(((Integer) data.get(134))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(135))); + (encoder).writeInt(((Integer) data.get(136))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(137))); + (encoder).writeInt(((Integer) data.get(138))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(139))); + (encoder).writeInt(((Integer) data.get(140))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(141))); + (encoder).writeInt(((Integer) data.get(142))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(143))); + (encoder).writeInt(((Integer) data.get(144))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(145))); + (encoder).writeInt(((Integer) data.get(146))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(147))); + (encoder).writeInt(((Integer) data.get(148))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(149))); + (encoder).writeInt(((Integer) data.get(150))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(151))); + (encoder).writeInt(((Integer) data.get(152))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(153))); + (encoder).writeInt(((Integer) data.get(154))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(155))); + (encoder).writeInt(((Integer) data.get(156))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(157))); + (encoder).writeInt(((Integer) data.get(158))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(159))); + (encoder).writeInt(((Integer) data.get(160))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(161))); + (encoder).writeInt(((Integer) data.get(162))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(163))); + (encoder).writeInt(((Integer) data.get(164))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(165))); + (encoder).writeInt(((Integer) data.get(166))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(167))); + (encoder).writeInt(((Integer) data.get(168))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(169))); + (encoder).writeInt(((Integer) data.get(170))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(171))); + (encoder).writeInt(((Integer) data.get(172))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(173))); + (encoder).writeInt(((Integer) data.get(174))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(175))); + (encoder).writeInt(((Integer) data.get(176))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(177))); + (encoder).writeInt(((Integer) data.get(178))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(179))); + (encoder).writeInt(((Integer) data.get(180))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(181))); + (encoder).writeInt(((Integer) data.get(182))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(183))); + (encoder).writeInt(((Integer) data.get(184))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(185))); + (encoder).writeInt(((Integer) data.get(186))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(187))); + (encoder).writeInt(((Integer) data.get(188))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(189))); + (encoder).writeInt(((Integer) data.get(190))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(191))); + (encoder).writeInt(((Integer) data.get(192))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(193))); + (encoder).writeInt(((Integer) data.get(194))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(195))); + (encoder).writeInt(((Integer) data.get(196))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(197))); + (encoder).writeInt(((Integer) data.get(198))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(199))); + (encoder).writeInt(((Integer) data.get(200))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(201))); + (encoder).writeInt(((Integer) data.get(202))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(203))); + (encoder).writeInt(((Integer) data.get(204))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(205))); + (encoder).writeInt(((Integer) data.get(206))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(207))); + (encoder).writeInt(((Integer) data.get(208))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(209))); + (encoder).writeInt(((Integer) data.get(210))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(211))); + (encoder).writeInt(((Integer) data.get(212))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(213))); + (encoder).writeInt(((Integer) data.get(214))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(215))); + (encoder).writeInt(((Integer) data.get(216))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(217))); + (encoder).writeInt(((Integer) data.get(218))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(219))); + (encoder).writeInt(((Integer) data.get(220))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(221))); + (encoder).writeInt(((Integer) data.get(222))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(223))); + (encoder).writeInt(((Integer) data.get(224))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(225))); + (encoder).writeInt(((Integer) data.get(226))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(227))); + (encoder).writeInt(((Integer) data.get(228))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(229))); + (encoder).writeInt(((Integer) data.get(230))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(231))); + (encoder).writeInt(((Integer) data.get(232))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(233))); + (encoder).writeInt(((Integer) data.get(234))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(235))); + (encoder).writeInt(((Integer) data.get(236))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(237))); + (encoder).writeInt(((Integer) data.get(238))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(239))); + (encoder).writeInt(((Integer) data.get(240))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(241))); + (encoder).writeInt(((Integer) data.get(242))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(243))); + (encoder).writeInt(((Integer) data.get(244))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(245))); + (encoder).writeInt(((Integer) data.get(246))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(247))); + (encoder).writeInt(((Integer) data.get(248))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(249))); + (encoder).writeInt(((Integer) data.get(250))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(251))); + (encoder).writeInt(((Integer) data.get(252))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(253))); + (encoder).writeInt(((Integer) data.get(254))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(255))); + (encoder).writeInt(((Integer) data.get(256))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(257))); + (encoder).writeInt(((Integer) data.get(258))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(259))); + (encoder).writeInt(((Integer) data.get(260))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(261))); + (encoder).writeInt(((Integer) data.get(262))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(263))); + (encoder).writeInt(((Integer) data.get(264))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(265))); + (encoder).writeInt(((Integer) data.get(266))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(267))); + (encoder).writeInt(((Integer) data.get(268))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(269))); + (encoder).writeInt(((Integer) data.get(270))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(271))); + (encoder).writeInt(((Integer) data.get(272))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(273))); + (encoder).writeInt(((Integer) data.get(274))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(275))); + (encoder).writeInt(((Integer) data.get(276))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(277))); + (encoder).writeInt(((Integer) data.get(278))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(279))); + (encoder).writeInt(((Integer) data.get(280))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(281))); + (encoder).writeInt(((Integer) data.get(282))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(283))); + (encoder).writeInt(((Integer) data.get(284))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(285))); + (encoder).writeInt(((Integer) data.get(286))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(287))); + (encoder).writeInt(((Integer) data.get(288))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(289))); + (encoder).writeInt(((Integer) data.get(290))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(291))); + (encoder).writeInt(((Integer) data.get(292))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(293))); + (encoder).writeInt(((Integer) data.get(294))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(295))); + (encoder).writeInt(((Integer) data.get(296))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(297))); + (encoder).writeInt(((Integer) data.get(298))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(299))); + (encoder).writeInt(((Integer) data.get(300))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(301))); + (encoder).writeInt(((Integer) data.get(302))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(303))); + (encoder).writeInt(((Integer) data.get(304))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(305))); + (encoder).writeInt(((Integer) data.get(306))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(307))); + (encoder).writeInt(((Integer) data.get(308))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(309))); + (encoder).writeInt(((Integer) data.get(310))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(311))); + (encoder).writeInt(((Integer) data.get(312))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(313))); + (encoder).writeInt(((Integer) data.get(314))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(315))); + (encoder).writeInt(((Integer) data.get(316))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(317))); + (encoder).writeInt(((Integer) data.get(318))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(319))); + (encoder).writeInt(((Integer) data.get(320))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(321))); + (encoder).writeInt(((Integer) data.get(322))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(323))); + (encoder).writeInt(((Integer) data.get(324))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(325))); + (encoder).writeInt(((Integer) data.get(326))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(327))); + (encoder).writeInt(((Integer) data.get(328))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(329))); + (encoder).writeInt(((Integer) data.get(330))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(331))); + (encoder).writeInt(((Integer) data.get(332))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(333))); + (encoder).writeInt(((Integer) data.get(334))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(335))); + (encoder).writeInt(((Integer) data.get(336))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(337))); + (encoder).writeInt(((Integer) data.get(338))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(339))); + (encoder).writeInt(((Integer) data.get(340))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(341))); + (encoder).writeInt(((Integer) data.get(342))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(343))); + (encoder).writeInt(((Integer) data.get(344))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(345))); + (encoder).writeInt(((Integer) data.get(346))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(347))); + (encoder).writeInt(((Integer) data.get(348))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(349))); + (encoder).writeInt(((Integer) data.get(350))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(351))); + (encoder).writeInt(((Integer) data.get(352))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(353))); + (encoder).writeInt(((Integer) data.get(354))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(355))); + (encoder).writeInt(((Integer) data.get(356))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(357))); + (encoder).writeInt(((Integer) data.get(358))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(359))); + (encoder).writeInt(((Integer) data.get(360))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(361))); + (encoder).writeInt(((Integer) data.get(362))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(363))); + (encoder).writeInt(((Integer) data.get(364))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(365))); + (encoder).writeInt(((Integer) data.get(366))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(367))); + (encoder).writeInt(((Integer) data.get(368))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(369))); + (encoder).writeInt(((Integer) data.get(370))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(371))); + (encoder).writeInt(((Integer) data.get(372))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(373))); + (encoder).writeInt(((Integer) data.get(374))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(375))); + (encoder).writeInt(((Integer) data.get(376))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(377))); + (encoder).writeInt(((Integer) data.get(378))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(379))); + (encoder).writeInt(((Integer) data.get(380))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(381))); + (encoder).writeInt(((Integer) data.get(382))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(383))); + (encoder).writeInt(((Integer) data.get(384))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(385))); + (encoder).writeInt(((Integer) data.get(386))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(387))); + (encoder).writeInt(((Integer) data.get(388))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(389))); + (encoder).writeInt(((Integer) data.get(390))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(391))); + (encoder).writeInt(((Integer) data.get(392))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(393))); + (encoder).writeInt(((Integer) data.get(394))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(395))); + (encoder).writeInt(((Integer) data.get(396))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(397))); + (encoder).writeInt(((Integer) data.get(398))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(399))); + (encoder).writeInt(((Integer) data.get(400))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(401))); + (encoder).writeInt(((Integer) data.get(402))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(403))); + (encoder).writeInt(((Integer) data.get(404))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(405))); + (encoder).writeInt(((Integer) data.get(406))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(407))); + (encoder).writeInt(((Integer) data.get(408))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(409))); + (encoder).writeInt(((Integer) data.get(410))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(411))); + (encoder).writeInt(((Integer) data.get(412))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(413))); + (encoder).writeInt(((Integer) data.get(414))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(415))); + (encoder).writeInt(((Integer) data.get(416))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(417))); + (encoder).writeInt(((Integer) data.get(418))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(419))); + (encoder).writeInt(((Integer) data.get(420))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(421))); + (encoder).writeInt(((Integer) data.get(422))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(423))); + (encoder).writeInt(((Integer) data.get(424))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(425))); + (encoder).writeInt(((Integer) data.get(426))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(427))); + (encoder).writeInt(((Integer) data.get(428))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(429))); + (encoder).writeInt(((Integer) data.get(430))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(431))); + (encoder).writeInt(((Integer) data.get(432))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(433))); + (encoder).writeInt(((Integer) data.get(434))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(435))); + (encoder).writeInt(((Integer) data.get(436))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(437))); + (encoder).writeInt(((Integer) data.get(438))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(439))); + (encoder).writeInt(((Integer) data.get(440))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(441))); + (encoder).writeInt(((Integer) data.get(442))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(443))); + (encoder).writeInt(((Integer) data.get(444))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(445))); + (encoder).writeInt(((Integer) data.get(446))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(447))); + (encoder).writeInt(((Integer) data.get(448))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(449))); + (encoder).writeInt(((Integer) data.get(450))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(451))); + (encoder).writeInt(((Integer) data.get(452))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(453))); + (encoder).writeInt(((Integer) data.get(454))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(455))); + (encoder).writeInt(((Integer) data.get(456))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(457))); + (encoder).writeInt(((Integer) data.get(458))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(459))); + (encoder).writeInt(((Integer) data.get(460))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(461))); + (encoder).writeInt(((Integer) data.get(462))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(463))); + (encoder).writeInt(((Integer) data.get(464))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(465))); + (encoder).writeInt(((Integer) data.get(466))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(467))); + (encoder).writeInt(((Integer) data.get(468))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(469))); + (encoder).writeInt(((Integer) data.get(470))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(471))); + (encoder).writeInt(((Integer) data.get(472))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(473))); + (encoder).writeInt(((Integer) data.get(474))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(475))); + (encoder).writeInt(((Integer) data.get(476))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(477))); + (encoder).writeInt(((Integer) data.get(478))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(479))); + (encoder).writeInt(((Integer) data.get(480))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(481))); + (encoder).writeInt(((Integer) data.get(482))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(483))); + (encoder).writeInt(((Integer) data.get(484))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(485))); + (encoder).writeInt(((Integer) data.get(486))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(487))); + (encoder).writeInt(((Integer) data.get(488))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(489))); + (encoder).writeInt(((Integer) data.get(490))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(491))); + (encoder).writeInt(((Integer) data.get(492))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(493))); + (encoder).writeInt(((Integer) data.get(494))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(495))); + (encoder).writeInt(((Integer) data.get(496))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(497))); + (encoder).writeInt(((Integer) data.get(498))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(499))); + (encoder).writeInt(((Integer) data.get(500))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(501))); + (encoder).writeInt(((Integer) data.get(502))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(503))); + (encoder).writeInt(((Integer) data.get(504))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(505))); + (encoder).writeInt(((Integer) data.get(506))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(507))); + (encoder).writeInt(((Integer) data.get(508))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(509))); + (encoder).writeInt(((Integer) data.get(510))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(511))); + (encoder).writeInt(((Integer) data.get(512))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(513))); + (encoder).writeInt(((Integer) data.get(514))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(515))); + (encoder).writeInt(((Integer) data.get(516))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(517))); + (encoder).writeInt(((Integer) data.get(518))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(519))); + (encoder).writeInt(((Integer) data.get(520))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(521))); + (encoder).writeInt(((Integer) data.get(522))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(523))); + (encoder).writeInt(((Integer) data.get(524))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(525))); + (encoder).writeInt(((Integer) data.get(526))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(527))); + (encoder).writeInt(((Integer) data.get(528))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(529))); + (encoder).writeInt(((Integer) data.get(530))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(531))); + (encoder).writeInt(((Integer) data.get(532))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(533))); + (encoder).writeInt(((Integer) data.get(534))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(535))); + (encoder).writeInt(((Integer) data.get(536))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(537))); + (encoder).writeInt(((Integer) data.get(538))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(539))); + (encoder).writeInt(((Integer) data.get(540))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(541))); + (encoder).writeInt(((Integer) data.get(542))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(543))); + (encoder).writeInt(((Integer) data.get(544))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(545))); + (encoder).writeInt(((Integer) data.get(546))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(547))); + (encoder).writeInt(((Integer) data.get(548))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(549))); + (encoder).writeInt(((Integer) data.get(550))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(551))); + (encoder).writeInt(((Integer) data.get(552))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(553))); + (encoder).writeInt(((Integer) data.get(554))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(555))); + (encoder).writeInt(((Integer) data.get(556))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(557))); + (encoder).writeInt(((Integer) data.get(558))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(559))); + (encoder).writeInt(((Integer) data.get(560))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(561))); + (encoder).writeInt(((Integer) data.get(562))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(563))); + (encoder).writeInt(((Integer) data.get(564))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(565))); + (encoder).writeInt(((Integer) data.get(566))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(567))); + (encoder).writeInt(((Integer) data.get(568))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(569))); + (encoder).writeInt(((Integer) data.get(570))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(571))); + (encoder).writeInt(((Integer) data.get(572))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(573))); + (encoder).writeInt(((Integer) data.get(574))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(575))); + (encoder).writeInt(((Integer) data.get(576))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(577))); + (encoder).writeInt(((Integer) data.get(578))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(579))); + (encoder).writeInt(((Integer) data.get(580))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(581))); + (encoder).writeInt(((Integer) data.get(582))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(583))); + (encoder).writeInt(((Integer) data.get(584))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(585))); + (encoder).writeInt(((Integer) data.get(586))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(587))); + (encoder).writeInt(((Integer) data.get(588))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(589))); + (encoder).writeInt(((Integer) data.get(590))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(591))); + (encoder).writeInt(((Integer) data.get(592))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(593))); + (encoder).writeInt(((Integer) data.get(594))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(595))); + (encoder).writeInt(((Integer) data.get(596))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(597))); + (encoder).writeInt(((Integer) data.get(598))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(599))); + (encoder).writeInt(((Integer) data.get(600))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(601))); + (encoder).writeInt(((Integer) data.get(602))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(603))); + (encoder).writeInt(((Integer) data.get(604))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(605))); + (encoder).writeInt(((Integer) data.get(606))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(607))); + (encoder).writeInt(((Integer) data.get(608))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(609))); + (encoder).writeInt(((Integer) data.get(610))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(611))); + (encoder).writeInt(((Integer) data.get(612))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(613))); + (encoder).writeInt(((Integer) data.get(614))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(615))); + (encoder).writeInt(((Integer) data.get(616))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(617))); + (encoder).writeInt(((Integer) data.get(618))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(619))); + (encoder).writeInt(((Integer) data.get(620))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(621))); + (encoder).writeInt(((Integer) data.get(622))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(623))); + (encoder).writeInt(((Integer) data.get(624))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(625))); + (encoder).writeInt(((Integer) data.get(626))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(627))); + (encoder).writeInt(((Integer) data.get(628))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(629))); + (encoder).writeInt(((Integer) data.get(630))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(631))); + (encoder).writeInt(((Integer) data.get(632))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(633))); + (encoder).writeInt(((Integer) data.get(634))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(635))); + (encoder).writeInt(((Integer) data.get(636))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(637))); + (encoder).writeInt(((Integer) data.get(638))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(639))); + (encoder).writeInt(((Integer) data.get(640))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(641))); + (encoder).writeInt(((Integer) data.get(642))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(643))); + (encoder).writeInt(((Integer) data.get(644))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(645))); + (encoder).writeInt(((Integer) data.get(646))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(647))); + (encoder).writeInt(((Integer) data.get(648))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(649))); + (encoder).writeInt(((Integer) data.get(650))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(651))); + (encoder).writeInt(((Integer) data.get(652))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(653))); + (encoder).writeInt(((Integer) data.get(654))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(655))); + (encoder).writeInt(((Integer) data.get(656))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(657))); + (encoder).writeInt(((Integer) data.get(658))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(659))); + (encoder).writeInt(((Integer) data.get(660))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(661))); + (encoder).writeInt(((Integer) data.get(662))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(663))); + (encoder).writeInt(((Integer) data.get(664))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(665))); + (encoder).writeInt(((Integer) data.get(666))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(667))); + (encoder).writeInt(((Integer) data.get(668))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(669))); + (encoder).writeInt(((Integer) data.get(670))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(671))); + (encoder).writeInt(((Integer) data.get(672))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(673))); + (encoder).writeInt(((Integer) data.get(674))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(675))); + (encoder).writeInt(((Integer) data.get(676))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(677))); + (encoder).writeInt(((Integer) data.get(678))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(679))); + (encoder).writeInt(((Integer) data.get(680))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(681))); + (encoder).writeInt(((Integer) data.get(682))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(683))); + (encoder).writeInt(((Integer) data.get(684))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(685))); + (encoder).writeInt(((Integer) data.get(686))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(687))); + (encoder).writeInt(((Integer) data.get(688))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(689))); + (encoder).writeInt(((Integer) data.get(690))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(691))); + (encoder).writeInt(((Integer) data.get(692))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(693))); + (encoder).writeInt(((Integer) data.get(694))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(695))); + (encoder).writeInt(((Integer) data.get(696))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(697))); + (encoder).writeInt(((Integer) data.get(698))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(699))); + (encoder).writeInt(((Integer) data.get(700))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(701))); + (encoder).writeInt(((Integer) data.get(702))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(703))); + (encoder).writeInt(((Integer) data.get(704))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(705))); + (encoder).writeInt(((Integer) data.get(706))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(707))); + (encoder).writeInt(((Integer) data.get(708))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(709))); + (encoder).writeInt(((Integer) data.get(710))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(711))); + (encoder).writeInt(((Integer) data.get(712))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(713))); + (encoder).writeInt(((Integer) data.get(714))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(715))); + (encoder).writeInt(((Integer) data.get(716))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(717))); + (encoder).writeInt(((Integer) data.get(718))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(719))); + (encoder).writeInt(((Integer) data.get(720))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(721))); + (encoder).writeInt(((Integer) data.get(722))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(723))); + (encoder).writeInt(((Integer) data.get(724))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(725))); + (encoder).writeInt(((Integer) data.get(726))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(727))); + (encoder).writeInt(((Integer) data.get(728))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(729))); + (encoder).writeInt(((Integer) data.get(730))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(731))); + (encoder).writeInt(((Integer) data.get(732))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(733))); + (encoder).writeInt(((Integer) data.get(734))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(735))); + (encoder).writeInt(((Integer) data.get(736))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(737))); + (encoder).writeInt(((Integer) data.get(738))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(739))); + (encoder).writeInt(((Integer) data.get(740))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(741))); + (encoder).writeInt(((Integer) data.get(742))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(743))); + (encoder).writeInt(((Integer) data.get(744))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(745))); + (encoder).writeInt(((Integer) data.get(746))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(747))); + (encoder).writeInt(((Integer) data.get(748))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(749))); + (encoder).writeInt(((Integer) data.get(750))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(751))); + (encoder).writeInt(((Integer) data.get(752))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(753))); + (encoder).writeInt(((Integer) data.get(754))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(755))); + (encoder).writeInt(((Integer) data.get(756))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(757))); + (encoder).writeInt(((Integer) data.get(758))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(759))); + (encoder).writeInt(((Integer) data.get(760))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(761))); + (encoder).writeInt(((Integer) data.get(762))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(763))); + (encoder).writeInt(((Integer) data.get(764))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(765))); + (encoder).writeInt(((Integer) data.get(766))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(767))); + (encoder).writeInt(((Integer) data.get(768))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(769))); + (encoder).writeInt(((Integer) data.get(770))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(771))); + (encoder).writeInt(((Integer) data.get(772))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(773))); + (encoder).writeInt(((Integer) data.get(774))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(775))); + (encoder).writeInt(((Integer) data.get(776))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(777))); + (encoder).writeInt(((Integer) data.get(778))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(779))); + (encoder).writeInt(((Integer) data.get(780))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(781))); + (encoder).writeInt(((Integer) data.get(782))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(783))); + (encoder).writeInt(((Integer) data.get(784))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(785))); + (encoder).writeInt(((Integer) data.get(786))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(787))); + (encoder).writeInt(((Integer) data.get(788))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(789))); + (encoder).writeInt(((Integer) data.get(790))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(791))); + (encoder).writeInt(((Integer) data.get(792))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(793))); + (encoder).writeInt(((Integer) data.get(794))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(795))); + (encoder).writeInt(((Integer) data.get(796))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(797))); + (encoder).writeInt(((Integer) data.get(798))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(799))); + (encoder).writeInt(((Integer) data.get(800))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(801))); + (encoder).writeInt(((Integer) data.get(802))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(803))); + (encoder).writeInt(((Integer) data.get(804))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(805))); + (encoder).writeInt(((Integer) data.get(806))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(807))); + (encoder).writeInt(((Integer) data.get(808))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(809))); + (encoder).writeInt(((Integer) data.get(810))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(811))); + (encoder).writeInt(((Integer) data.get(812))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(813))); + (encoder).writeInt(((Integer) data.get(814))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(815))); + (encoder).writeInt(((Integer) data.get(816))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(817))); + (encoder).writeInt(((Integer) data.get(818))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(819))); + (encoder).writeInt(((Integer) data.get(820))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(821))); + (encoder).writeInt(((Integer) data.get(822))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(823))); + (encoder).writeInt(((Integer) data.get(824))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(825))); + (encoder).writeInt(((Integer) data.get(826))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(827))); + (encoder).writeInt(((Integer) data.get(828))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(829))); + (encoder).writeInt(((Integer) data.get(830))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(831))); + (encoder).writeInt(((Integer) data.get(832))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(833))); + (encoder).writeInt(((Integer) data.get(834))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(835))); + (encoder).writeInt(((Integer) data.get(836))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(837))); + (encoder).writeInt(((Integer) data.get(838))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(839))); + (encoder).writeInt(((Integer) data.get(840))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(841))); + (encoder).writeInt(((Integer) data.get(842))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(843))); + (encoder).writeInt(((Integer) data.get(844))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(845))); + (encoder).writeInt(((Integer) data.get(846))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(847))); + (encoder).writeInt(((Integer) data.get(848))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(849))); + (encoder).writeInt(((Integer) data.get(850))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(851))); + (encoder).writeInt(((Integer) data.get(852))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(853))); + (encoder).writeInt(((Integer) data.get(854))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(855))); + (encoder).writeInt(((Integer) data.get(856))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(857))); + (encoder).writeInt(((Integer) data.get(858))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(859))); + (encoder).writeInt(((Integer) data.get(860))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(861))); + (encoder).writeInt(((Integer) data.get(862))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(863))); + (encoder).writeInt(((Integer) data.get(864))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(865))); + (encoder).writeInt(((Integer) data.get(866))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(867))); + (encoder).writeInt(((Integer) data.get(868))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(869))); + (encoder).writeInt(((Integer) data.get(870))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(871))); + (encoder).writeInt(((Integer) data.get(872))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(873))); + (encoder).writeInt(((Integer) data.get(874))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(875))); + (encoder).writeInt(((Integer) data.get(876))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(877))); + (encoder).writeInt(((Integer) data.get(878))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(879))); + (encoder).writeInt(((Integer) data.get(880))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(881))); + (encoder).writeInt(((Integer) data.get(882))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(883))); + (encoder).writeInt(((Integer) data.get(884))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(885))); + (encoder).writeInt(((Integer) data.get(886))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(887))); + (encoder).writeInt(((Integer) data.get(888))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(889))); + (encoder).writeInt(((Integer) data.get(890))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(891))); + (encoder).writeInt(((Integer) data.get(892))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(893))); + (encoder).writeInt(((Integer) data.get(894))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(895))); + (encoder).writeInt(((Integer) data.get(896))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(897))); + (encoder).writeInt(((Integer) data.get(898))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(899))); + (encoder).writeInt(((Integer) data.get(900))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(901))); + (encoder).writeInt(((Integer) data.get(902))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(903))); + (encoder).writeInt(((Integer) data.get(904))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(905))); + (encoder).writeInt(((Integer) data.get(906))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(907))); + (encoder).writeInt(((Integer) data.get(908))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(909))); + (encoder).writeInt(((Integer) data.get(910))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(911))); + (encoder).writeInt(((Integer) data.get(912))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(913))); + (encoder).writeInt(((Integer) data.get(914))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(915))); + (encoder).writeInt(((Integer) data.get(916))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(917))); + (encoder).writeInt(((Integer) data.get(918))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(919))); + (encoder).writeInt(((Integer) data.get(920))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(921))); + (encoder).writeInt(((Integer) data.get(922))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(923))); + (encoder).writeInt(((Integer) data.get(924))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(925))); + (encoder).writeInt(((Integer) data.get(926))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(927))); + (encoder).writeInt(((Integer) data.get(928))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(929))); + (encoder).writeInt(((Integer) data.get(930))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(931))); + (encoder).writeInt(((Integer) data.get(932))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(933))); + (encoder).writeInt(((Integer) data.get(934))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(935))); + (encoder).writeInt(((Integer) data.get(936))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(937))); + (encoder).writeInt(((Integer) data.get(938))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(939))); + (encoder).writeInt(((Integer) data.get(940))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(941))); + (encoder).writeInt(((Integer) data.get(942))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(943))); + (encoder).writeInt(((Integer) data.get(944))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(945))); + (encoder).writeInt(((Integer) data.get(946))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(947))); + (encoder).writeInt(((Integer) data.get(948))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(949))); + (encoder).writeInt(((Integer) data.get(950))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(951))); + (encoder).writeInt(((Integer) data.get(952))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(953))); + (encoder).writeInt(((Integer) data.get(954))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(955))); + (encoder).writeInt(((Integer) data.get(956))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(957))); + (encoder).writeInt(((Integer) data.get(958))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(959))); + (encoder).writeInt(((Integer) data.get(960))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(961))); + (encoder).writeInt(((Integer) data.get(962))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(963))); + (encoder).writeInt(((Integer) data.get(964))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(965))); + (encoder).writeInt(((Integer) data.get(966))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(967))); + (encoder).writeInt(((Integer) data.get(968))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(969))); + (encoder).writeInt(((Integer) data.get(970))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(971))); + (encoder).writeInt(((Integer) data.get(972))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(973))); + (encoder).writeInt(((Integer) data.get(974))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(975))); + (encoder).writeInt(((Integer) data.get(976))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(977))); + (encoder).writeInt(((Integer) data.get(978))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(979))); + (encoder).writeInt(((Integer) data.get(980))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(981))); + (encoder).writeInt(((Integer) data.get(982))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(983))); + (encoder).writeInt(((Integer) data.get(984))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(985))); + (encoder).writeInt(((Integer) data.get(986))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(987))); + (encoder).writeInt(((Integer) data.get(988))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(989))); + (encoder).writeInt(((Integer) data.get(990))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(991))); + (encoder).writeInt(((Integer) data.get(992))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(993))); + (encoder).writeInt(((Integer) data.get(994))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(995))); + (encoder).writeInt(((Integer) data.get(996))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(997))); + (encoder).writeInt(((Integer) data.get(998))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(999))); + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java new file mode 100644 index 000000000..cf19f0cc7 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java @@ -0,0 +1,116 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + int valueToWrite0; + Object enumValue0 = data.get(0); + if (enumValue0 instanceof Enum) { + valueToWrite0 = ((Enum) enumValue0).ordinal(); + } else { + valueToWrite0 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).toString()); + } + (encoder).writeEnum(valueToWrite0); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + GenericEnumSymbol testEnumUnion0 = ((GenericEnumSymbol) data.get(1)); + if (testEnumUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((testEnumUnion0 instanceof GenericEnumSymbol)&&"com.linkedin.avro.fastserde.generated.avro.testEnum".equals(((GenericEnumSymbol) testEnumUnion0).getSchema().getFullName())) { + (encoder).writeIndex(1); + int valueToWrite1; + Object enumValue1 = testEnumUnion0; + if (enumValue1 instanceof Enum) { + valueToWrite1 = ((Enum) enumValue1).ordinal(); + } else { + valueToWrite1 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).toString()); + } + (encoder).writeEnum(valueToWrite1); + } + } + List testEnumArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testEnumArray0 == null)||testEnumArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testEnumArray0 .size()); + for (int counter0 = 0; (counter0 testEnumUnionArray0 = ((List ) data.get(3)); + (encoder).writeArrayStart(); + if ((testEnumUnionArray0 == null)||testEnumUnionArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testEnumUnionArray0 .size()); + for (int counter1 = 0; (counter1 ) testEnumUnionArray0).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof GenericEnumSymbol)&&"com.linkedin.avro.fastserde.generated.avro.testEnum".equals(((GenericEnumSymbol) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + int valueToWrite3; + Object enumValue3 = union0; + if (enumValue3 instanceof Enum) { + valueToWrite3 = ((Enum) enumValue3).ordinal(); + } else { + valueToWrite3 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue3).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue3).toString()); + } + (encoder).writeEnum(valueToWrite3); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java new file mode 100644 index 000000000..1cfb6a182 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java @@ -0,0 +1,88 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + GenericFixed testFixedUnion0 = ((GenericFixed) data.get(1)); + if (testFixedUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((testFixedUnion0 instanceof GenericFixed)&&"com.linkedin.avro.fastserde.generated.avro.testFixed".equals(((GenericFixed) testFixedUnion0).getSchema().getFullName())) { + (encoder).writeIndex(1); + (encoder).writeFixed(((GenericFixed) testFixedUnion0).bytes()); + } + } + List testFixedArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testFixedArray0 == null)||testFixedArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testFixedArray0 .size()); + for (int counter0 = 0; (counter0 testFixedUnionArray0 = ((List ) data.get(3)); + (encoder).writeArrayStart(); + if ((testFixedUnionArray0 == null)||testFixedUnionArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testFixedUnionArray0 .size()); + for (int counter1 = 0; (counter1 ) testFixedUnionArray0).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof GenericFixed)&&"com.linkedin.avro.fastserde.generated.avro.testFixed".equals(((GenericFixed) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + (encoder).writeFixed(((GenericFixed) union0).bytes()); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java new file mode 100644 index 000000000..2185503e5 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java @@ -0,0 +1,70 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object union0 = ((Object) data.get(0)); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } else { + if (union0 instanceof CharSequence) { + (encoder).writeIndex(2); + if (((CharSequence) union0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) union0))); + } else { + (encoder).writeString(((CharSequence) union0).toString()); + } + } else { + if (union0 instanceof Integer) { + (encoder).writeIndex(3); + (encoder).writeInt(((Integer) union0)); + } + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java new file mode 100644 index 000000000..181e6e0a8 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java @@ -0,0 +1,157 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import java.nio.ByteBuffer; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Integer testIntUnion0 = ((Integer) data.get(1)); + if (testIntUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeInt(((Integer) testIntUnion0)); + } + Integer testFlippedIntUnion0 = ((Integer) data.get(2)); + if (testFlippedIntUnion0 == null) { + (encoder).writeIndex(1); + (encoder).writeNull(); + } else { + (encoder).writeIndex(0); + (encoder).writeInt(((Integer) testFlippedIntUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(3)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(3)))); + } else { + (encoder).writeString(((CharSequence) data.get(3)).toString()); + } + CharSequence testStringUnion0 = ((CharSequence) data.get(4)); + if (testStringUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testStringUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringUnion0))); + } else { + (encoder).writeString(((CharSequence) testStringUnion0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeLong(((Long) data.get(5))); + Long testLongUnion0 = ((Long) data.get(6)); + if (testLongUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeLong(((Long) testLongUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeDouble(((Double) data.get(7))); + Double testDoubleUnion0 = ((Double) data.get(8)); + if (testDoubleUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeDouble(((Double) testDoubleUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFloat(((Float) data.get(9))); + Float testFloatUnion0 = ((Float) data.get(10)); + if (testFloatUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeFloat(((Float) testFloatUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeBoolean(((Boolean) data.get(11))); + Boolean testBooleanUnion0 = ((Boolean) data.get(12)); + if (testBooleanUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeBoolean(((Boolean) testBooleanUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeBytes(((ByteBuffer) data.get(13))); + ByteBuffer testBytesUnion0 = ((ByteBuffer) data.get(14)); + if (testBytesUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeBytes(((ByteBuffer) testBytesUnion0)); + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java new file mode 100644 index 000000000..9830bbd0f --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object union_field0 = ((Object) data.get(0)); + if (union_field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record1".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord10(((IndexedRecord) union_field0), (encoder), (customization)); + } else { + if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record2".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { + (encoder).writeIndex(2); + serializeRecord20(((IndexedRecord) union_field0), (encoder), (customization)); + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + } + + @SuppressWarnings("unchecked") + public void serializeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java new file mode 100644 index 000000000..5e0637301 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java @@ -0,0 +1,158 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List recordsArray0 = ((List ) data.get(0)); + (encoder).writeArrayStart(); + if ((recordsArray0 == null)||recordsArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsArray0 .size()); + for (int counter0 = 0; (counter0 ) recordsArray0).get(counter0); + serializeSubRecord0(subRecord0, (encoder), (customization)); + } + } + (encoder).writeArrayEnd(); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map recordsMap0 = ((Map ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMap0); + } + (encoder).writeMapStart(); + if ((recordsMap0 == null)||recordsMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsMap0 .size()); + for (CharSequence key0 : ((Map ) recordsMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord subRecord1 = null; + subRecord1 = ((Map ) recordsMap0).get(key0); + serializeSubRecord0(subRecord1, (encoder), (customization)); + } + } + (encoder).writeMapEnd(); + List recordsArrayUnion0 = ((List ) data.get(2)); + if (recordsArrayUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsArrayUnion0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) recordsArrayUnion0) == null)||((List ) recordsArrayUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) recordsArrayUnion0).size()); + for (int counter1 = 0; (counter1 <((List ) recordsArrayUnion0).size()); counter1 ++) { + (encoder).startItem(); + IndexedRecord union0 = null; + union0 = ((List )((List ) recordsArrayUnion0)).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map recordsMapUnion0 = ((Map ) data.get(3)); + if (recordsMapUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsMapUnion0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map ) recordsMapUnion0)); + } + (encoder).writeMapStart(); + if ((((Map ) recordsMapUnion0) == null)||((Map ) recordsMapUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map ) recordsMapUnion0).size()); + for (CharSequence key1 : ((Map )((Map ) recordsMapUnion0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + IndexedRecord union1 = null; + union1 = ((Map )((Map ) recordsMapUnion0)).get(key1); + if (union1 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java new file mode 100644 index 000000000..c550edf3b --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java @@ -0,0 +1,230 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List> recordsArrayMap0 = ((List> ) data.get(0)); + (encoder).writeArrayStart(); + if ((recordsArrayMap0 == null)||recordsArrayMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsArrayMap0 .size()); + for (int counter0 = 0; (counter0 map0 = null; + map0 = ((List> ) recordsArrayMap0).get(counter0); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map0); + } + (encoder).writeMapStart(); + if ((map0 == null)||map0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(map0 .size()); + for (CharSequence key0 : ((Map ) map0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord union0 = null; + union0 = ((Map ) map0).get(key0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + (encoder).writeArrayEnd(); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map> recordsMapArray0 = ((Map> ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMapArray0); + } + (encoder).writeMapStart(); + if ((recordsMapArray0 == null)||recordsMapArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsMapArray0 .size()); + for (CharSequence key1 : ((Map> ) recordsMapArray0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + List array0 = null; + array0 = ((Map> ) recordsMapArray0).get(key1); + (encoder).writeArrayStart(); + if ((array0 == null)||array0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array0 .size()); + for (int counter1 = 0; (counter1 ) array0).get(counter1); + if (union1 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + (encoder).writeMapEnd(); + List> recordsArrayMapUnion0 = ((List> ) data.get(2)); + if (recordsArrayMapUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsArrayMapUnion0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List> ) recordsArrayMapUnion0) == null)||((List> ) recordsArrayMapUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List> ) recordsArrayMapUnion0).size()); + for (int counter2 = 0; (counter2 <((List> ) recordsArrayMapUnion0).size()); counter2 ++) { + (encoder).startItem(); + Map map1 = null; + map1 = ((List> )((List> ) recordsArrayMapUnion0)).get(counter2); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map1); + } + (encoder).writeMapStart(); + if ((map1 == null)||map1 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(map1 .size()); + for (CharSequence key2 : ((Map ) map1).keySet()) { + (encoder).startItem(); + (encoder).writeString(key2); + IndexedRecord union2 = null; + union2 = ((Map ) map1).get(key2); + if (union2 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union2 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union2).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union2), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + (encoder).writeArrayEnd(); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map> recordsMapArrayUnion0 = ((Map> ) data.get(3)); + if (recordsMapArrayUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsMapArrayUnion0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map> ) recordsMapArrayUnion0)); + } + (encoder).writeMapStart(); + if ((((Map> ) recordsMapArrayUnion0) == null)||((Map> ) recordsMapArrayUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map> ) recordsMapArrayUnion0).size()); + for (CharSequence key3 : ((Map> )((Map> ) recordsMapArrayUnion0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key3); + List array1 = null; + array1 = ((Map> )((Map> ) recordsMapArrayUnion0)).get(key3); + (encoder).writeArrayStart(); + if ((array1 == null)||array1 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array1 .size()); + for (int counter3 = 0; (counter3 ) array1).get(counter3); + if (union3 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union3 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union3).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union3), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + (encoder).writeMapEnd(); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java new file mode 100644 index 000000000..6195e028e --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + IndexedRecord record0 = ((IndexedRecord) data.get(0)); + if (record0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((record0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) record0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) record0), (encoder), (customization)); + } + } + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + IndexedRecord record10 = ((IndexedRecord) data.get(1)); + serializeSubRecord0(record10, (encoder), (customization)); + CharSequence field0 = ((CharSequence) data.get(2)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastSerdeEnums_GenericSerializer_957378572.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastSerdeEnums_GenericSerializer_957378572.java new file mode 100644 index 000000000..877fcff35 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastSerdeEnums_GenericSerializer_957378572.java @@ -0,0 +1,95 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeEnums_GenericSerializer_957378572 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + int valueToWrite0; + Object enumValue0 = data.get(0); + if (enumValue0 instanceof Enum) { + valueToWrite0 = ((Enum) enumValue0).ordinal(); + } else { + valueToWrite0 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).toString()); + } + (encoder).writeEnum(valueToWrite0); + serialize_FastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List arrayOfEnums0 = ((List ) data.get(1)); + if (arrayOfEnums0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (arrayOfEnums0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) arrayOfEnums0) == null)||((List ) arrayOfEnums0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) arrayOfEnums0).size()); + for (int counter0 = 0; (counter0 <((List ) arrayOfEnums0).size()); counter0 ++) { + (encoder).startItem(); + int valueToWrite1; + Object enumValue1 = ((List ) arrayOfEnums0).get(counter0); + if (enumValue1 instanceof Enum) { + valueToWrite1 = ((Enum) enumValue1).ordinal(); + } else { + valueToWrite1 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).toString()); + } + (encoder).writeEnum(valueToWrite1); + } + } + (encoder).writeArrayEnd(); + } + } + Map mapOfEnums0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfEnums0); + } + (encoder).writeMapStart(); + if ((mapOfEnums0 == null)||mapOfEnums0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfEnums0 .size()); + for (CharSequence key0 : ((Map ) mapOfEnums0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + int valueToWrite2; + Object enumValue2 = mapOfEnums0 .get(key0); + if (enumValue2 instanceof Enum) { + valueToWrite2 = ((Enum) enumValue2).ordinal(); + } else { + valueToWrite2 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue2).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue2).toString()); + } + (encoder).writeEnum(valueToWrite2); + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastSerdeFixed_GenericSerializer_504108934.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastSerdeFixed_GenericSerializer_504108934.java new file mode 100644 index 000000000..a0722f62a --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastSerdeFixed_GenericSerializer_504108934.java @@ -0,0 +1,74 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeFixed_GenericSerializer_504108934 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List arrayOfFixed0 = ((List ) data.get(1)); + if (arrayOfFixed0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (arrayOfFixed0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) arrayOfFixed0) == null)||((List ) arrayOfFixed0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) arrayOfFixed0).size()); + for (int counter0 = 0; (counter0 <((List ) arrayOfFixed0).size()); counter0 ++) { + (encoder).startItem(); + (encoder).writeFixed(((GenericFixed)((List ) arrayOfFixed0).get(counter0)).bytes()); + } + } + (encoder).writeArrayEnd(); + } + } + Map mapOfFixed0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfFixed0); + } + (encoder).writeMapStart(); + if ((mapOfFixed0 == null)||mapOfFixed0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfFixed0 .size()); + for (CharSequence key0 : ((Map ) mapOfFixed0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + (encoder).writeFixed(((GenericFixed) mapOfFixed0 .get(key0)).bytes()); + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java new file mode 100644 index 000000000..175c90253 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java @@ -0,0 +1,97 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence testUnionString0 = ((CharSequence) data.get(1)); + if (testUnionString0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testUnionString0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testUnionString0))); + } else { + (encoder).writeString(((CharSequence) testUnionString0).toString()); + } + } + List testStringArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testStringArray0 == null)||testStringArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringArray0 .size()); + for (int counter0 = 0; (counter0 testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } + (encoder).writeMapStart(); + if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringMap0 .size()); + for (CharSequence key0 : ((Map ) testStringMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) testStringMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) testStringMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java new file mode 100644 index 000000000..5eb40676c --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java @@ -0,0 +1,97 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_FastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence testUnionString0 = ((CharSequence) data.get(1)); + if (testUnionString0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testUnionString0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testUnionString0))); + } else { + (encoder).writeString(((CharSequence) testUnionString0).toString()); + } + } + List testStringArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testStringArray0 == null)||testStringArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringArray0 .size()); + for (int counter0 = 0; (counter0 testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } + (encoder).writeMapStart(); + if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringMap0 .size()); + for (CharSequence key0 : ((Map ) testStringMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) testStringMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) testStringMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/Map_of_UNION_GenericSerializer_2140000109.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/Map_of_UNION_GenericSerializer_2140000109.java new file mode 100644 index 000000000..be6d17838 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/Map_of_UNION_GenericSerializer_2140000109.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Map_of_UNION_GenericSerializer_2140000109 + implements FastSerializer> +{ + + + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } + (encoder).writeMapStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (CharSequence key0 : ((Map ) data).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord union0 = null; + union0 = ((Map ) data).get(key0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/Map_of_record_GenericSerializer_1677529043.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/Map_of_record_GenericSerializer_1677529043.java new file mode 100644 index 000000000..f8fb74396 --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/Map_of_record_GenericSerializer_1677529043.java @@ -0,0 +1,57 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Map_of_record_GenericSerializer_1677529043 + implements FastSerializer> +{ + + + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } + (encoder).writeMapStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (CharSequence key0 : ((Map ) data).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord record0 = null; + record0 = ((Map ) data).get(key0); + serializeRecord0(record0, (encoder), (customization)); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/StringableRecord_SpecificSerializer_842267318.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/StringableRecord_SpecificSerializer_842267318.java new file mode 100644 index 000000000..90ef4fadb --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/StringableRecord_SpecificSerializer_842267318.java @@ -0,0 +1,159 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.File; +import java.io.IOException; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.net.URI; +import java.net.URL; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord; +import com.linkedin.avro.fastserde.generated.avro.StringableRecord; +import com.linkedin.avro.fastserde.generated.avro.StringableSubRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class StringableRecord_SpecificSerializer_842267318 + implements FastSerializer +{ + + + public void serialize(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeStringableRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((BigInteger) data.get(0)).toString()); + serialize_StringableRecord0(data, (encoder), (customization)); + serialize_StringableRecord1(data, (encoder), (customization)); + serialize_StringableRecord2(data, (encoder), (customization)); + serialize_StringableRecord3(data, (encoder), (customization)); + serialize_StringableRecord4(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((BigDecimal) data.get(1)).toString()); + (encoder).writeString(((URI) data.get(2)).toString()); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord1(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((URL) data.get(3)).toString()); + (encoder).writeString(((File) data.get(4)).toString()); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord2(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List urlArray0 = ((List ) data.get(5)); + (encoder).writeArrayStart(); + if ((urlArray0 == null)||urlArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(urlArray0 .size()); + for (int counter0 = 0; (counter0 urlMap0 = ((Map ) data.get(6)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(urlMap0); + } + (encoder).writeMapStart(); + if ((urlMap0 == null)||urlMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(urlMap0 .size()); + for (URL key0 : ((Map ) urlMap0).keySet()) { + (encoder).startItem(); + String keyString0 = key0 .toString(); + (encoder).writeString(keyString0); + (encoder).writeString(((BigInteger) urlMap0 .get(key0)).toString()); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord3(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord0 = ((StringableSubRecord) data.get(7)); + serializeStringableSubRecord0(subRecord0, (encoder), (customization)); + AnotherSubRecord subRecordWithSubRecord0 = ((AnotherSubRecord) data.get(8)); + serializeAnotherSubRecord0(subRecordWithSubRecord0, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((URI) data.get(0)).toString()); + serialize_StringableSubRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object nullStringIntUnion0 = ((Object) data.get(1)); + if (nullStringIntUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (nullStringIntUnion0 instanceof CharSequence) { + (encoder).writeIndex(1); + if (((CharSequence) nullStringIntUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) nullStringIntUnion0))); + } else { + (encoder).writeString(((CharSequence) nullStringIntUnion0).toString()); + } + } else { + if (nullStringIntUnion0 instanceof Integer) { + (encoder).writeIndex(2); + (encoder).writeInt(((Integer) nullStringIntUnion0)); + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeAnotherSubRecord0(AnotherSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord1 = ((StringableSubRecord) data.get(0)); + serializeStringableSubRecord0(subRecord1, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord4(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + String stringUnion0 = ((String) data.get(9)); + if (stringUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeString(((String) stringUnion0).toString()); + } + } + +} diff --git a/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/TestArrayOfFloats_GenericSerializer_1408566797.java b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/TestArrayOfFloats_GenericSerializer_1408566797.java new file mode 100644 index 000000000..67a64c89c --- /dev/null +++ b/fastserde/avro-fastserde-tests17/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_7/TestArrayOfFloats_GenericSerializer_1408566797.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_7; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class TestArrayOfFloats_GenericSerializer_1408566797 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeTestArrayOfFloats0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeTestArrayOfFloats0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List array_of_float0 = ((List ) data.get(0)); + (encoder).writeArrayStart(); + if ((array_of_float0 == null)||array_of_float0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array_of_float0 .size()); + Object array0 = array_of_float0; + if (array0 instanceof PrimitiveFloatList) { + PrimitiveFloatList primitiveList0 = ((PrimitiveFloatList) array0); + if (primitiveList0 instanceof BufferBackedPrimitiveFloatList) { + BufferBackedPrimitiveFloatList bufferBackedPrimitiveFloatList = ((BufferBackedPrimitiveFloatList) primitiveList0); + bufferBackedPrimitiveFloatList.writeFloats((encoder)); + } else { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_BOOLEAN_GenericDeserializer_869749973_869749973(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveBooleanList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveBooleanList) { + array0 = ((PrimitiveBooleanList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveBooleanArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_DOUBLE_GenericDeserializer_18760307_18760307(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveDoubleList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveDoubleList) { + array0 = ((PrimitiveDoubleList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveDoubleArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_FLOAT_GenericDeserializer_1012670397_1012670397(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveFloatList array0 = null; + array0 = ((PrimitiveFloatList) BufferBackedPrimitiveFloatList.readPrimitiveFloatArray((reuse), (decoder))); + return array0; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/Array_of_INT_GenericDeserializer_1012089072_1012089072.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/Array_of_INT_GenericDeserializer_1012089072_1012089072.java new file mode 100644 index 000000000..6a8f125cc --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/Array_of_INT_GenericDeserializer_1012089072_1012089072.java @@ -0,0 +1,43 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class Array_of_INT_GenericDeserializer_1012089072_1012089072 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Array_of_INT_GenericDeserializer_1012089072_1012089072(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveIntList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveIntList) { + array0 = ((PrimitiveIntList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_LONG_GenericDeserializer_325099267_325099267(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveLongList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveLongList) { + array0 = ((PrimitiveLongList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveLongArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_TestRecord_SpecificDeserializer_1088113243_1088113243(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema arrayArrayElemSchema0; + private final Schema arrayElemOptionSchema0; + private final Schema field0; + + public Array_of_UNION_GenericDeserializer_777827233_777827233(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArrayElemSchema0 = readerSchema.getElementType(); + this.arrayElemOptionSchema0 = arrayArrayElemSchema0 .getTypes().get(1); + this.field0 = arrayElemOptionSchema0 .getField("field").schema(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_UNION_SpecificDeserializer_1277939469_1277939469(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex15 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex17)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex21 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex21)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex23 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex23)); + } + } + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex25 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex25 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex25 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex25)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema unionOptionArrayElemSchema0; + + public Array_of_record_GenericDeserializer_1606337179_2018567528(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOptionArrayElemSchema0 = readerSchema.getElementType(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":{\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}}"); + } else { + if (unionIndex0 == 1) { + List unionOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + unionOption0 = ((List)(reuse)); + unionOption0 .clear(); + } else { + unionOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + private final Schema arrayArrayElemSchema0; + private final Schema field0; + + public Array_of_record_GenericDeserializer_477614132_477614132(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArrayElemSchema0 = readerSchema.getElementType(); + this.field0 = arrayArrayElemSchema0 .getField("field").schema(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema f00; + private final Schema f10; + private final Schema f20; + private final Schema f30; + private final Schema f40; + private final Schema f50; + private final Schema f60; + private final Schema f70; + private final Schema f80; + private final Schema f90; + private final Schema f100; + private final Schema f110; + private final Schema f120; + private final Schema f130; + private final Schema f140; + private final Schema f150; + private final Schema f160; + private final Schema f170; + private final Schema f180; + private final Schema f190; + private final Schema f200; + private final Schema f210; + private final Schema f220; + private final Schema f230; + private final Schema f240; + private final Schema f250; + private final Schema f260; + private final Schema f270; + private final Schema f280; + private final Schema f290; + private final Schema f300; + private final Schema f310; + private final Schema f320; + private final Schema f330; + private final Schema f340; + private final Schema f350; + private final Schema f360; + private final Schema f370; + private final Schema f380; + private final Schema f390; + private final Schema f400; + private final Schema f410; + private final Schema f420; + private final Schema f430; + private final Schema f440; + private final Schema f450; + private final Schema f460; + private final Schema f470; + private final Schema f480; + private final Schema f490; + private final Schema f500; + private final Schema f510; + private final Schema f520; + private final Schema f530; + private final Schema f540; + private final Schema f550; + private final Schema f560; + private final Schema f570; + private final Schema f580; + private final Schema f590; + private final Schema f600; + private final Schema f610; + private final Schema f620; + private final Schema f630; + private final Schema f640; + private final Schema f650; + private final Schema f660; + private final Schema f670; + private final Schema f680; + private final Schema f690; + private final Schema f700; + private final Schema f710; + private final Schema f720; + private final Schema f730; + private final Schema f740; + private final Schema f750; + private final Schema f760; + private final Schema f770; + private final Schema f780; + private final Schema f790; + private final Schema f800; + private final Schema f810; + private final Schema f820; + private final Schema f830; + private final Schema f840; + private final Schema f850; + private final Schema f860; + private final Schema f870; + private final Schema f880; + private final Schema f890; + private final Schema f900; + private final Schema f910; + private final Schema f920; + private final Schema f930; + private final Schema f940; + private final Schema f950; + private final Schema f960; + private final Schema f970; + private final Schema f980; + private final Schema f990; + private final Schema f1000; + private final Schema f1010; + private final Schema f1020; + private final Schema f1030; + private final Schema f1040; + private final Schema f1050; + private final Schema f1060; + private final Schema f1070; + private final Schema f1080; + private final Schema f1090; + private final Schema f1100; + private final Schema f1110; + private final Schema f1120; + private final Schema f1130; + private final Schema f1140; + private final Schema f1150; + private final Schema f1160; + private final Schema f1170; + private final Schema f1180; + private final Schema f1190; + private final Schema f1200; + private final Schema f1210; + private final Schema f1220; + private final Schema f1230; + private final Schema f1240; + private final Schema f1250; + private final Schema f1260; + private final Schema f1270; + private final Schema f1280; + private final Schema f1290; + private final Schema f1300; + private final Schema f1310; + private final Schema f1320; + private final Schema f1330; + private final Schema f1340; + private final Schema f1350; + private final Schema f1360; + private final Schema f1370; + private final Schema f1380; + private final Schema f1390; + private final Schema f1400; + private final Schema f1410; + private final Schema f1420; + private final Schema f1430; + private final Schema f1440; + private final Schema f1450; + private final Schema f1460; + private final Schema f1470; + private final Schema f1480; + private final Schema f1490; + private final Schema f1500; + private final Schema f1510; + private final Schema f1520; + private final Schema f1530; + private final Schema f1540; + private final Schema f1550; + private final Schema f1560; + private final Schema f1570; + private final Schema f1580; + private final Schema f1590; + private final Schema f1600; + private final Schema f1610; + private final Schema f1620; + private final Schema f1630; + private final Schema f1640; + private final Schema f1650; + private final Schema f1660; + private final Schema f1670; + private final Schema f1680; + private final Schema f1690; + private final Schema f1700; + private final Schema f1710; + private final Schema f1720; + private final Schema f1730; + private final Schema f1740; + private final Schema f1750; + private final Schema f1760; + private final Schema f1770; + private final Schema f1780; + private final Schema f1790; + private final Schema f1800; + private final Schema f1810; + private final Schema f1820; + private final Schema f1830; + private final Schema f1840; + private final Schema f1850; + private final Schema f1860; + private final Schema f1870; + private final Schema f1880; + private final Schema f1890; + private final Schema f1900; + private final Schema f1910; + private final Schema f1920; + private final Schema f1930; + private final Schema f1940; + private final Schema f1950; + private final Schema f1960; + private final Schema f1970; + private final Schema f1980; + private final Schema f1990; + private final Schema f2000; + private final Schema f2010; + private final Schema f2020; + private final Schema f2030; + private final Schema f2040; + private final Schema f2050; + private final Schema f2060; + private final Schema f2070; + private final Schema f2080; + private final Schema f2090; + private final Schema f2100; + private final Schema f2110; + private final Schema f2120; + private final Schema f2130; + private final Schema f2140; + private final Schema f2150; + private final Schema f2160; + private final Schema f2170; + private final Schema f2180; + private final Schema f2190; + private final Schema f2200; + private final Schema f2210; + private final Schema f2220; + private final Schema f2230; + private final Schema f2240; + private final Schema f2250; + private final Schema f2260; + private final Schema f2270; + private final Schema f2280; + private final Schema f2290; + private final Schema f2300; + private final Schema f2310; + private final Schema f2320; + private final Schema f2330; + private final Schema f2340; + private final Schema f2350; + private final Schema f2360; + private final Schema f2370; + private final Schema f2380; + private final Schema f2390; + private final Schema f2400; + private final Schema f2410; + private final Schema f2420; + private final Schema f2430; + private final Schema f2440; + private final Schema f2450; + private final Schema f2460; + private final Schema f2470; + private final Schema f2480; + private final Schema f2490; + private final Schema f2500; + private final Schema f2510; + private final Schema f2520; + private final Schema f2530; + private final Schema f2540; + private final Schema f2550; + private final Schema f2560; + private final Schema f2570; + private final Schema f2580; + private final Schema f2590; + private final Schema f2600; + private final Schema f2610; + private final Schema f2620; + private final Schema f2630; + private final Schema f2640; + private final Schema f2650; + private final Schema f2660; + private final Schema f2670; + private final Schema f2680; + private final Schema f2690; + private final Schema f2700; + private final Schema f2710; + private final Schema f2720; + private final Schema f2730; + private final Schema f2740; + private final Schema f2750; + private final Schema f2760; + private final Schema f2770; + private final Schema f2780; + private final Schema f2790; + private final Schema f2800; + private final Schema f2810; + private final Schema f2820; + private final Schema f2830; + private final Schema f2840; + private final Schema f2850; + private final Schema f2860; + private final Schema f2870; + private final Schema f2880; + private final Schema f2890; + private final Schema f2900; + private final Schema f2910; + private final Schema f2920; + private final Schema f2930; + private final Schema f2940; + private final Schema f2950; + private final Schema f2960; + private final Schema f2970; + private final Schema f2980; + private final Schema f2990; + private final Schema f3000; + private final Schema f3010; + private final Schema f3020; + private final Schema f3030; + private final Schema f3040; + private final Schema f3050; + private final Schema f3060; + private final Schema f3070; + private final Schema f3080; + private final Schema f3090; + private final Schema f3100; + private final Schema f3110; + private final Schema f3120; + private final Schema f3130; + private final Schema f3140; + private final Schema f3150; + private final Schema f3160; + private final Schema f3170; + private final Schema f3180; + private final Schema f3190; + private final Schema f3200; + private final Schema f3210; + private final Schema f3220; + private final Schema f3230; + private final Schema f3240; + private final Schema f3250; + private final Schema f3260; + private final Schema f3270; + private final Schema f3280; + private final Schema f3290; + private final Schema f3300; + private final Schema f3310; + private final Schema f3320; + private final Schema f3330; + private final Schema f3340; + private final Schema f3350; + private final Schema f3360; + private final Schema f3370; + private final Schema f3380; + private final Schema f3390; + private final Schema f3400; + private final Schema f3410; + private final Schema f3420; + private final Schema f3430; + private final Schema f3440; + private final Schema f3450; + private final Schema f3460; + private final Schema f3470; + private final Schema f3480; + private final Schema f3490; + private final Schema f3500; + private final Schema f3510; + private final Schema f3520; + private final Schema f3530; + private final Schema f3540; + private final Schema f3550; + private final Schema f3560; + private final Schema f3570; + private final Schema f3580; + private final Schema f3590; + private final Schema f3600; + private final Schema f3610; + private final Schema f3620; + private final Schema f3630; + private final Schema f3640; + private final Schema f3650; + private final Schema f3660; + private final Schema f3670; + private final Schema f3680; + private final Schema f3690; + private final Schema f3700; + private final Schema f3710; + private final Schema f3720; + private final Schema f3730; + private final Schema f3740; + private final Schema f3750; + private final Schema f3760; + private final Schema f3770; + private final Schema f3780; + private final Schema f3790; + private final Schema f3800; + private final Schema f3810; + private final Schema f3820; + private final Schema f3830; + private final Schema f3840; + private final Schema f3850; + private final Schema f3860; + private final Schema f3870; + private final Schema f3880; + private final Schema f3890; + private final Schema f3900; + private final Schema f3910; + private final Schema f3920; + private final Schema f3930; + private final Schema f3940; + private final Schema f3950; + private final Schema f3960; + private final Schema f3970; + private final Schema f3980; + private final Schema f3990; + private final Schema f4000; + private final Schema f4010; + private final Schema f4020; + private final Schema f4030; + private final Schema f4040; + private final Schema f4050; + private final Schema f4060; + private final Schema f4070; + private final Schema f4080; + private final Schema f4090; + private final Schema f4100; + private final Schema f4110; + private final Schema f4120; + private final Schema f4130; + private final Schema f4140; + private final Schema f4150; + private final Schema f4160; + private final Schema f4170; + private final Schema f4180; + private final Schema f4190; + private final Schema f4200; + private final Schema f4210; + private final Schema f4220; + private final Schema f4230; + private final Schema f4240; + private final Schema f4250; + private final Schema f4260; + private final Schema f4270; + private final Schema f4280; + private final Schema f4290; + private final Schema f4300; + private final Schema f4310; + private final Schema f4320; + private final Schema f4330; + private final Schema f4340; + private final Schema f4350; + private final Schema f4360; + private final Schema f4370; + private final Schema f4380; + private final Schema f4390; + private final Schema f4400; + private final Schema f4410; + private final Schema f4420; + private final Schema f4430; + private final Schema f4440; + private final Schema f4450; + private final Schema f4460; + private final Schema f4470; + private final Schema f4480; + private final Schema f4490; + private final Schema f4500; + private final Schema f4510; + private final Schema f4520; + private final Schema f4530; + private final Schema f4540; + private final Schema f4550; + private final Schema f4560; + private final Schema f4570; + private final Schema f4580; + private final Schema f4590; + private final Schema f4600; + private final Schema f4610; + private final Schema f4620; + private final Schema f4630; + private final Schema f4640; + private final Schema f4650; + private final Schema f4660; + private final Schema f4670; + private final Schema f4680; + private final Schema f4690; + private final Schema f4700; + private final Schema f4710; + private final Schema f4720; + private final Schema f4730; + private final Schema f4740; + private final Schema f4750; + private final Schema f4760; + private final Schema f4770; + private final Schema f4780; + private final Schema f4790; + private final Schema f4800; + private final Schema f4810; + private final Schema f4820; + private final Schema f4830; + private final Schema f4840; + private final Schema f4850; + private final Schema f4860; + private final Schema f4870; + private final Schema f4880; + private final Schema f4890; + private final Schema f4900; + private final Schema f4910; + private final Schema f4920; + private final Schema f4930; + private final Schema f4940; + private final Schema f4950; + private final Schema f4960; + private final Schema f4970; + private final Schema f4980; + private final Schema f4990; + private final Schema f5000; + private final Schema f5010; + private final Schema f5020; + private final Schema f5030; + private final Schema f5040; + private final Schema f5050; + private final Schema f5060; + private final Schema f5070; + private final Schema f5080; + private final Schema f5090; + private final Schema f5100; + private final Schema f5110; + private final Schema f5120; + private final Schema f5130; + private final Schema f5140; + private final Schema f5150; + private final Schema f5160; + private final Schema f5170; + private final Schema f5180; + private final Schema f5190; + private final Schema f5200; + private final Schema f5210; + private final Schema f5220; + private final Schema f5230; + private final Schema f5240; + private final Schema f5250; + private final Schema f5260; + private final Schema f5270; + private final Schema f5280; + private final Schema f5290; + private final Schema f5300; + private final Schema f5310; + private final Schema f5320; + private final Schema f5330; + private final Schema f5340; + private final Schema f5350; + private final Schema f5360; + private final Schema f5370; + private final Schema f5380; + private final Schema f5390; + private final Schema f5400; + private final Schema f5410; + private final Schema f5420; + private final Schema f5430; + private final Schema f5440; + private final Schema f5450; + private final Schema f5460; + private final Schema f5470; + private final Schema f5480; + private final Schema f5490; + private final Schema f5500; + private final Schema f5510; + private final Schema f5520; + private final Schema f5530; + private final Schema f5540; + private final Schema f5550; + private final Schema f5560; + private final Schema f5570; + private final Schema f5580; + private final Schema f5590; + private final Schema f5600; + private final Schema f5610; + private final Schema f5620; + private final Schema f5630; + private final Schema f5640; + private final Schema f5650; + private final Schema f5660; + private final Schema f5670; + private final Schema f5680; + private final Schema f5690; + private final Schema f5700; + private final Schema f5710; + private final Schema f5720; + private final Schema f5730; + private final Schema f5740; + private final Schema f5750; + private final Schema f5760; + private final Schema f5770; + private final Schema f5780; + private final Schema f5790; + private final Schema f5800; + private final Schema f5810; + private final Schema f5820; + private final Schema f5830; + private final Schema f5840; + private final Schema f5850; + private final Schema f5860; + private final Schema f5870; + private final Schema f5880; + private final Schema f5890; + private final Schema f5900; + private final Schema f5910; + private final Schema f5920; + private final Schema f5930; + private final Schema f5940; + private final Schema f5950; + private final Schema f5960; + private final Schema f5970; + private final Schema f5980; + private final Schema f5990; + private final Schema f6000; + private final Schema f6010; + private final Schema f6020; + private final Schema f6030; + private final Schema f6040; + private final Schema f6050; + private final Schema f6060; + private final Schema f6070; + private final Schema f6080; + private final Schema f6090; + private final Schema f6100; + private final Schema f6110; + private final Schema f6120; + private final Schema f6130; + private final Schema f6140; + private final Schema f6150; + private final Schema f6160; + private final Schema f6170; + private final Schema f6180; + private final Schema f6190; + private final Schema f6200; + private final Schema f6210; + private final Schema f6220; + private final Schema f6230; + private final Schema f6240; + private final Schema f6250; + private final Schema f6260; + private final Schema f6270; + private final Schema f6280; + private final Schema f6290; + private final Schema f6300; + private final Schema f6310; + private final Schema f6320; + private final Schema f6330; + private final Schema f6340; + private final Schema f6350; + private final Schema f6360; + private final Schema f6370; + private final Schema f6380; + private final Schema f6390; + private final Schema f6400; + private final Schema f6410; + private final Schema f6420; + private final Schema f6430; + private final Schema f6440; + private final Schema f6450; + private final Schema f6460; + private final Schema f6470; + private final Schema f6480; + private final Schema f6490; + private final Schema f6500; + private final Schema f6510; + private final Schema f6520; + private final Schema f6530; + private final Schema f6540; + private final Schema f6550; + private final Schema f6560; + private final Schema f6570; + private final Schema f6580; + private final Schema f6590; + private final Schema f6600; + private final Schema f6610; + private final Schema f6620; + private final Schema f6630; + private final Schema f6640; + private final Schema f6650; + private final Schema f6660; + private final Schema f6670; + private final Schema f6680; + private final Schema f6690; + private final Schema f6700; + private final Schema f6710; + private final Schema f6720; + private final Schema f6730; + private final Schema f6740; + private final Schema f6750; + private final Schema f6760; + private final Schema f6770; + private final Schema f6780; + private final Schema f6790; + private final Schema f6800; + private final Schema f6810; + private final Schema f6820; + private final Schema f6830; + private final Schema f6840; + private final Schema f6850; + private final Schema f6860; + private final Schema f6870; + private final Schema f6880; + private final Schema f6890; + private final Schema f6900; + private final Schema f6910; + private final Schema f6920; + private final Schema f6930; + private final Schema f6940; + private final Schema f6950; + private final Schema f6960; + private final Schema f6970; + private final Schema f6980; + private final Schema f6990; + private final Schema f7000; + private final Schema f7010; + private final Schema f7020; + private final Schema f7030; + private final Schema f7040; + private final Schema f7050; + private final Schema f7060; + private final Schema f7070; + private final Schema f7080; + private final Schema f7090; + private final Schema f7100; + private final Schema f7110; + private final Schema f7120; + private final Schema f7130; + private final Schema f7140; + private final Schema f7150; + private final Schema f7160; + private final Schema f7170; + private final Schema f7180; + private final Schema f7190; + private final Schema f7200; + private final Schema f7210; + private final Schema f7220; + private final Schema f7230; + private final Schema f7240; + private final Schema f7250; + private final Schema f7260; + private final Schema f7270; + private final Schema f7280; + private final Schema f7290; + private final Schema f7300; + private final Schema f7310; + private final Schema f7320; + private final Schema f7330; + private final Schema f7340; + private final Schema f7350; + private final Schema f7360; + private final Schema f7370; + private final Schema f7380; + private final Schema f7390; + private final Schema f7400; + private final Schema f7410; + private final Schema f7420; + private final Schema f7430; + private final Schema f7440; + private final Schema f7450; + private final Schema f7460; + private final Schema f7470; + private final Schema f7480; + private final Schema f7490; + private final Schema f7500; + private final Schema f7510; + private final Schema f7520; + private final Schema f7530; + private final Schema f7540; + private final Schema f7550; + private final Schema f7560; + private final Schema f7570; + private final Schema f7580; + private final Schema f7590; + private final Schema f7600; + private final Schema f7610; + private final Schema f7620; + private final Schema f7630; + private final Schema f7640; + private final Schema f7650; + private final Schema f7660; + private final Schema f7670; + private final Schema f7680; + private final Schema f7690; + private final Schema f7700; + private final Schema f7710; + private final Schema f7720; + private final Schema f7730; + private final Schema f7740; + private final Schema f7750; + private final Schema f7760; + private final Schema f7770; + private final Schema f7780; + private final Schema f7790; + private final Schema f7800; + private final Schema f7810; + private final Schema f7820; + private final Schema f7830; + private final Schema f7840; + private final Schema f7850; + private final Schema f7860; + private final Schema f7870; + private final Schema f7880; + private final Schema f7890; + private final Schema f7900; + private final Schema f7910; + private final Schema f7920; + private final Schema f7930; + private final Schema f7940; + private final Schema f7950; + private final Schema f7960; + private final Schema f7970; + private final Schema f7980; + private final Schema f7990; + private final Schema f8000; + private final Schema f8010; + private final Schema f8020; + private final Schema f8030; + private final Schema f8040; + private final Schema f8050; + private final Schema f8060; + private final Schema f8070; + private final Schema f8080; + private final Schema f8090; + private final Schema f8100; + private final Schema f8110; + private final Schema f8120; + private final Schema f8130; + private final Schema f8140; + private final Schema f8150; + private final Schema f8160; + private final Schema f8170; + private final Schema f8180; + private final Schema f8190; + private final Schema f8200; + private final Schema f8210; + private final Schema f8220; + private final Schema f8230; + private final Schema f8240; + private final Schema f8250; + private final Schema f8260; + private final Schema f8270; + private final Schema f8280; + private final Schema f8290; + private final Schema f8300; + private final Schema f8310; + private final Schema f8320; + private final Schema f8330; + private final Schema f8340; + private final Schema f8350; + private final Schema f8360; + private final Schema f8370; + private final Schema f8380; + private final Schema f8390; + private final Schema f8400; + private final Schema f8410; + private final Schema f8420; + private final Schema f8430; + private final Schema f8440; + private final Schema f8450; + private final Schema f8460; + private final Schema f8470; + private final Schema f8480; + private final Schema f8490; + private final Schema f8500; + private final Schema f8510; + private final Schema f8520; + private final Schema f8530; + private final Schema f8540; + private final Schema f8550; + private final Schema f8560; + private final Schema f8570; + private final Schema f8580; + private final Schema f8590; + private final Schema f8600; + private final Schema f8610; + private final Schema f8620; + private final Schema f8630; + private final Schema f8640; + private final Schema f8650; + private final Schema f8660; + private final Schema f8670; + private final Schema f8680; + private final Schema f8690; + private final Schema f8700; + private final Schema f8710; + private final Schema f8720; + private final Schema f8730; + private final Schema f8740; + private final Schema f8750; + private final Schema f8760; + private final Schema f8770; + private final Schema f8780; + private final Schema f8790; + private final Schema f8800; + private final Schema f8810; + private final Schema f8820; + private final Schema f8830; + private final Schema f8840; + private final Schema f8850; + private final Schema f8860; + private final Schema f8870; + private final Schema f8880; + private final Schema f8890; + private final Schema f8900; + private final Schema f8910; + private final Schema f8920; + private final Schema f8930; + private final Schema f8940; + private final Schema f8950; + private final Schema f8960; + private final Schema f8970; + private final Schema f8980; + private final Schema f8990; + private final Schema f9000; + private final Schema f9010; + private final Schema f9020; + private final Schema f9030; + private final Schema f9040; + private final Schema f9050; + private final Schema f9060; + private final Schema f9070; + private final Schema f9080; + private final Schema f9090; + private final Schema f9100; + private final Schema f9110; + private final Schema f9120; + private final Schema f9130; + private final Schema f9140; + private final Schema f9150; + private final Schema f9160; + private final Schema f9170; + private final Schema f9180; + private final Schema f9190; + private final Schema f9200; + private final Schema f9210; + private final Schema f9220; + private final Schema f9230; + private final Schema f9240; + private final Schema f9250; + private final Schema f9260; + private final Schema f9270; + private final Schema f9280; + private final Schema f9290; + private final Schema f9300; + private final Schema f9310; + private final Schema f9320; + private final Schema f9330; + private final Schema f9340; + private final Schema f9350; + private final Schema f9360; + private final Schema f9370; + private final Schema f9380; + private final Schema f9390; + private final Schema f9400; + private final Schema f9410; + private final Schema f9420; + private final Schema f9430; + private final Schema f9440; + private final Schema f9450; + private final Schema f9460; + private final Schema f9470; + private final Schema f9480; + private final Schema f9490; + private final Schema f9500; + private final Schema f9510; + private final Schema f9520; + private final Schema f9530; + private final Schema f9540; + private final Schema f9550; + private final Schema f9560; + private final Schema f9570; + private final Schema f9580; + private final Schema f9590; + private final Schema f9600; + private final Schema f9610; + private final Schema f9620; + private final Schema f9630; + private final Schema f9640; + private final Schema f9650; + private final Schema f9660; + private final Schema f9670; + private final Schema f9680; + private final Schema f9690; + private final Schema f9700; + private final Schema f9710; + private final Schema f9720; + private final Schema f9730; + private final Schema f9740; + private final Schema f9750; + private final Schema f9760; + private final Schema f9770; + private final Schema f9780; + private final Schema f9790; + private final Schema f9800; + private final Schema f9810; + private final Schema f9820; + private final Schema f9830; + private final Schema f9840; + private final Schema f9850; + private final Schema f9860; + private final Schema f9870; + private final Schema f9880; + private final Schema f9890; + private final Schema f9900; + private final Schema f9910; + private final Schema f9920; + private final Schema f9930; + private final Schema f9940; + private final Schema f9950; + private final Schema f9960; + private final Schema f9970; + private final Schema f9980; + private final Schema f9990; + + public FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema_GenericDeserializer_836892732_836892732(Schema readerSchema) { + this.readerSchema = readerSchema; + this.f00 = readerSchema.getField("F0").schema(); + this.f10 = readerSchema.getField("F1").schema(); + this.f20 = readerSchema.getField("F2").schema(); + this.f30 = readerSchema.getField("F3").schema(); + this.f40 = readerSchema.getField("F4").schema(); + this.f50 = readerSchema.getField("F5").schema(); + this.f60 = readerSchema.getField("F6").schema(); + this.f70 = readerSchema.getField("F7").schema(); + this.f80 = readerSchema.getField("F8").schema(); + this.f90 = readerSchema.getField("F9").schema(); + this.f100 = readerSchema.getField("F10").schema(); + this.f110 = readerSchema.getField("F11").schema(); + this.f120 = readerSchema.getField("F12").schema(); + this.f130 = readerSchema.getField("F13").schema(); + this.f140 = readerSchema.getField("F14").schema(); + this.f150 = readerSchema.getField("F15").schema(); + this.f160 = readerSchema.getField("F16").schema(); + this.f170 = readerSchema.getField("F17").schema(); + this.f180 = readerSchema.getField("F18").schema(); + this.f190 = readerSchema.getField("F19").schema(); + this.f200 = readerSchema.getField("F20").schema(); + this.f210 = readerSchema.getField("F21").schema(); + this.f220 = readerSchema.getField("F22").schema(); + this.f230 = readerSchema.getField("F23").schema(); + this.f240 = readerSchema.getField("F24").schema(); + this.f250 = readerSchema.getField("F25").schema(); + this.f260 = readerSchema.getField("F26").schema(); + this.f270 = readerSchema.getField("F27").schema(); + this.f280 = readerSchema.getField("F28").schema(); + this.f290 = readerSchema.getField("F29").schema(); + this.f300 = readerSchema.getField("F30").schema(); + this.f310 = readerSchema.getField("F31").schema(); + this.f320 = readerSchema.getField("F32").schema(); + this.f330 = readerSchema.getField("F33").schema(); + this.f340 = readerSchema.getField("F34").schema(); + this.f350 = readerSchema.getField("F35").schema(); + this.f360 = readerSchema.getField("F36").schema(); + this.f370 = readerSchema.getField("F37").schema(); + this.f380 = readerSchema.getField("F38").schema(); + this.f390 = readerSchema.getField("F39").schema(); + this.f400 = readerSchema.getField("F40").schema(); + this.f410 = readerSchema.getField("F41").schema(); + this.f420 = readerSchema.getField("F42").schema(); + this.f430 = readerSchema.getField("F43").schema(); + this.f440 = readerSchema.getField("F44").schema(); + this.f450 = readerSchema.getField("F45").schema(); + this.f460 = readerSchema.getField("F46").schema(); + this.f470 = readerSchema.getField("F47").schema(); + this.f480 = readerSchema.getField("F48").schema(); + this.f490 = readerSchema.getField("F49").schema(); + this.f500 = readerSchema.getField("F50").schema(); + this.f510 = readerSchema.getField("F51").schema(); + this.f520 = readerSchema.getField("F52").schema(); + this.f530 = readerSchema.getField("F53").schema(); + this.f540 = readerSchema.getField("F54").schema(); + this.f550 = readerSchema.getField("F55").schema(); + this.f560 = readerSchema.getField("F56").schema(); + this.f570 = readerSchema.getField("F57").schema(); + this.f580 = readerSchema.getField("F58").schema(); + this.f590 = readerSchema.getField("F59").schema(); + this.f600 = readerSchema.getField("F60").schema(); + this.f610 = readerSchema.getField("F61").schema(); + this.f620 = readerSchema.getField("F62").schema(); + this.f630 = readerSchema.getField("F63").schema(); + this.f640 = readerSchema.getField("F64").schema(); + this.f650 = readerSchema.getField("F65").schema(); + this.f660 = readerSchema.getField("F66").schema(); + this.f670 = readerSchema.getField("F67").schema(); + this.f680 = readerSchema.getField("F68").schema(); + this.f690 = readerSchema.getField("F69").schema(); + this.f700 = readerSchema.getField("F70").schema(); + this.f710 = readerSchema.getField("F71").schema(); + this.f720 = readerSchema.getField("F72").schema(); + this.f730 = readerSchema.getField("F73").schema(); + this.f740 = readerSchema.getField("F74").schema(); + this.f750 = readerSchema.getField("F75").schema(); + this.f760 = readerSchema.getField("F76").schema(); + this.f770 = readerSchema.getField("F77").schema(); + this.f780 = readerSchema.getField("F78").schema(); + this.f790 = readerSchema.getField("F79").schema(); + this.f800 = readerSchema.getField("F80").schema(); + this.f810 = readerSchema.getField("F81").schema(); + this.f820 = readerSchema.getField("F82").schema(); + this.f830 = readerSchema.getField("F83").schema(); + this.f840 = readerSchema.getField("F84").schema(); + this.f850 = readerSchema.getField("F85").schema(); + this.f860 = readerSchema.getField("F86").schema(); + this.f870 = readerSchema.getField("F87").schema(); + this.f880 = readerSchema.getField("F88").schema(); + this.f890 = readerSchema.getField("F89").schema(); + this.f900 = readerSchema.getField("F90").schema(); + this.f910 = readerSchema.getField("F91").schema(); + this.f920 = readerSchema.getField("F92").schema(); + this.f930 = readerSchema.getField("F93").schema(); + this.f940 = readerSchema.getField("F94").schema(); + this.f950 = readerSchema.getField("F95").schema(); + this.f960 = readerSchema.getField("F96").schema(); + this.f970 = readerSchema.getField("F97").schema(); + this.f980 = readerSchema.getField("F98").schema(); + this.f990 = readerSchema.getField("F99").schema(); + this.f1000 = readerSchema.getField("F100").schema(); + this.f1010 = readerSchema.getField("F101").schema(); + this.f1020 = readerSchema.getField("F102").schema(); + this.f1030 = readerSchema.getField("F103").schema(); + this.f1040 = readerSchema.getField("F104").schema(); + this.f1050 = readerSchema.getField("F105").schema(); + this.f1060 = readerSchema.getField("F106").schema(); + this.f1070 = readerSchema.getField("F107").schema(); + this.f1080 = readerSchema.getField("F108").schema(); + this.f1090 = readerSchema.getField("F109").schema(); + this.f1100 = readerSchema.getField("F110").schema(); + this.f1110 = readerSchema.getField("F111").schema(); + this.f1120 = readerSchema.getField("F112").schema(); + this.f1130 = readerSchema.getField("F113").schema(); + this.f1140 = readerSchema.getField("F114").schema(); + this.f1150 = readerSchema.getField("F115").schema(); + this.f1160 = readerSchema.getField("F116").schema(); + this.f1170 = readerSchema.getField("F117").schema(); + this.f1180 = readerSchema.getField("F118").schema(); + this.f1190 = readerSchema.getField("F119").schema(); + this.f1200 = readerSchema.getField("F120").schema(); + this.f1210 = readerSchema.getField("F121").schema(); + this.f1220 = readerSchema.getField("F122").schema(); + this.f1230 = readerSchema.getField("F123").schema(); + this.f1240 = readerSchema.getField("F124").schema(); + this.f1250 = readerSchema.getField("F125").schema(); + this.f1260 = readerSchema.getField("F126").schema(); + this.f1270 = readerSchema.getField("F127").schema(); + this.f1280 = readerSchema.getField("F128").schema(); + this.f1290 = readerSchema.getField("F129").schema(); + this.f1300 = readerSchema.getField("F130").schema(); + this.f1310 = readerSchema.getField("F131").schema(); + this.f1320 = readerSchema.getField("F132").schema(); + this.f1330 = readerSchema.getField("F133").schema(); + this.f1340 = readerSchema.getField("F134").schema(); + this.f1350 = readerSchema.getField("F135").schema(); + this.f1360 = readerSchema.getField("F136").schema(); + this.f1370 = readerSchema.getField("F137").schema(); + this.f1380 = readerSchema.getField("F138").schema(); + this.f1390 = readerSchema.getField("F139").schema(); + this.f1400 = readerSchema.getField("F140").schema(); + this.f1410 = readerSchema.getField("F141").schema(); + this.f1420 = readerSchema.getField("F142").schema(); + this.f1430 = readerSchema.getField("F143").schema(); + this.f1440 = readerSchema.getField("F144").schema(); + this.f1450 = readerSchema.getField("F145").schema(); + this.f1460 = readerSchema.getField("F146").schema(); + this.f1470 = readerSchema.getField("F147").schema(); + this.f1480 = readerSchema.getField("F148").schema(); + this.f1490 = readerSchema.getField("F149").schema(); + this.f1500 = readerSchema.getField("F150").schema(); + this.f1510 = readerSchema.getField("F151").schema(); + this.f1520 = readerSchema.getField("F152").schema(); + this.f1530 = readerSchema.getField("F153").schema(); + this.f1540 = readerSchema.getField("F154").schema(); + this.f1550 = readerSchema.getField("F155").schema(); + this.f1560 = readerSchema.getField("F156").schema(); + this.f1570 = readerSchema.getField("F157").schema(); + this.f1580 = readerSchema.getField("F158").schema(); + this.f1590 = readerSchema.getField("F159").schema(); + this.f1600 = readerSchema.getField("F160").schema(); + this.f1610 = readerSchema.getField("F161").schema(); + this.f1620 = readerSchema.getField("F162").schema(); + this.f1630 = readerSchema.getField("F163").schema(); + this.f1640 = readerSchema.getField("F164").schema(); + this.f1650 = readerSchema.getField("F165").schema(); + this.f1660 = readerSchema.getField("F166").schema(); + this.f1670 = readerSchema.getField("F167").schema(); + this.f1680 = readerSchema.getField("F168").schema(); + this.f1690 = readerSchema.getField("F169").schema(); + this.f1700 = readerSchema.getField("F170").schema(); + this.f1710 = readerSchema.getField("F171").schema(); + this.f1720 = readerSchema.getField("F172").schema(); + this.f1730 = readerSchema.getField("F173").schema(); + this.f1740 = readerSchema.getField("F174").schema(); + this.f1750 = readerSchema.getField("F175").schema(); + this.f1760 = readerSchema.getField("F176").schema(); + this.f1770 = readerSchema.getField("F177").schema(); + this.f1780 = readerSchema.getField("F178").schema(); + this.f1790 = readerSchema.getField("F179").schema(); + this.f1800 = readerSchema.getField("F180").schema(); + this.f1810 = readerSchema.getField("F181").schema(); + this.f1820 = readerSchema.getField("F182").schema(); + this.f1830 = readerSchema.getField("F183").schema(); + this.f1840 = readerSchema.getField("F184").schema(); + this.f1850 = readerSchema.getField("F185").schema(); + this.f1860 = readerSchema.getField("F186").schema(); + this.f1870 = readerSchema.getField("F187").schema(); + this.f1880 = readerSchema.getField("F188").schema(); + this.f1890 = readerSchema.getField("F189").schema(); + this.f1900 = readerSchema.getField("F190").schema(); + this.f1910 = readerSchema.getField("F191").schema(); + this.f1920 = readerSchema.getField("F192").schema(); + this.f1930 = readerSchema.getField("F193").schema(); + this.f1940 = readerSchema.getField("F194").schema(); + this.f1950 = readerSchema.getField("F195").schema(); + this.f1960 = readerSchema.getField("F196").schema(); + this.f1970 = readerSchema.getField("F197").schema(); + this.f1980 = readerSchema.getField("F198").schema(); + this.f1990 = readerSchema.getField("F199").schema(); + this.f2000 = readerSchema.getField("F200").schema(); + this.f2010 = readerSchema.getField("F201").schema(); + this.f2020 = readerSchema.getField("F202").schema(); + this.f2030 = readerSchema.getField("F203").schema(); + this.f2040 = readerSchema.getField("F204").schema(); + this.f2050 = readerSchema.getField("F205").schema(); + this.f2060 = readerSchema.getField("F206").schema(); + this.f2070 = readerSchema.getField("F207").schema(); + this.f2080 = readerSchema.getField("F208").schema(); + this.f2090 = readerSchema.getField("F209").schema(); + this.f2100 = readerSchema.getField("F210").schema(); + this.f2110 = readerSchema.getField("F211").schema(); + this.f2120 = readerSchema.getField("F212").schema(); + this.f2130 = readerSchema.getField("F213").schema(); + this.f2140 = readerSchema.getField("F214").schema(); + this.f2150 = readerSchema.getField("F215").schema(); + this.f2160 = readerSchema.getField("F216").schema(); + this.f2170 = readerSchema.getField("F217").schema(); + this.f2180 = readerSchema.getField("F218").schema(); + this.f2190 = readerSchema.getField("F219").schema(); + this.f2200 = readerSchema.getField("F220").schema(); + this.f2210 = readerSchema.getField("F221").schema(); + this.f2220 = readerSchema.getField("F222").schema(); + this.f2230 = readerSchema.getField("F223").schema(); + this.f2240 = readerSchema.getField("F224").schema(); + this.f2250 = readerSchema.getField("F225").schema(); + this.f2260 = readerSchema.getField("F226").schema(); + this.f2270 = readerSchema.getField("F227").schema(); + this.f2280 = readerSchema.getField("F228").schema(); + this.f2290 = readerSchema.getField("F229").schema(); + this.f2300 = readerSchema.getField("F230").schema(); + this.f2310 = readerSchema.getField("F231").schema(); + this.f2320 = readerSchema.getField("F232").schema(); + this.f2330 = readerSchema.getField("F233").schema(); + this.f2340 = readerSchema.getField("F234").schema(); + this.f2350 = readerSchema.getField("F235").schema(); + this.f2360 = readerSchema.getField("F236").schema(); + this.f2370 = readerSchema.getField("F237").schema(); + this.f2380 = readerSchema.getField("F238").schema(); + this.f2390 = readerSchema.getField("F239").schema(); + this.f2400 = readerSchema.getField("F240").schema(); + this.f2410 = readerSchema.getField("F241").schema(); + this.f2420 = readerSchema.getField("F242").schema(); + this.f2430 = readerSchema.getField("F243").schema(); + this.f2440 = readerSchema.getField("F244").schema(); + this.f2450 = readerSchema.getField("F245").schema(); + this.f2460 = readerSchema.getField("F246").schema(); + this.f2470 = readerSchema.getField("F247").schema(); + this.f2480 = readerSchema.getField("F248").schema(); + this.f2490 = readerSchema.getField("F249").schema(); + this.f2500 = readerSchema.getField("F250").schema(); + this.f2510 = readerSchema.getField("F251").schema(); + this.f2520 = readerSchema.getField("F252").schema(); + this.f2530 = readerSchema.getField("F253").schema(); + this.f2540 = readerSchema.getField("F254").schema(); + this.f2550 = readerSchema.getField("F255").schema(); + this.f2560 = readerSchema.getField("F256").schema(); + this.f2570 = readerSchema.getField("F257").schema(); + this.f2580 = readerSchema.getField("F258").schema(); + this.f2590 = readerSchema.getField("F259").schema(); + this.f2600 = readerSchema.getField("F260").schema(); + this.f2610 = readerSchema.getField("F261").schema(); + this.f2620 = readerSchema.getField("F262").schema(); + this.f2630 = readerSchema.getField("F263").schema(); + this.f2640 = readerSchema.getField("F264").schema(); + this.f2650 = readerSchema.getField("F265").schema(); + this.f2660 = readerSchema.getField("F266").schema(); + this.f2670 = readerSchema.getField("F267").schema(); + this.f2680 = readerSchema.getField("F268").schema(); + this.f2690 = readerSchema.getField("F269").schema(); + this.f2700 = readerSchema.getField("F270").schema(); + this.f2710 = readerSchema.getField("F271").schema(); + this.f2720 = readerSchema.getField("F272").schema(); + this.f2730 = readerSchema.getField("F273").schema(); + this.f2740 = readerSchema.getField("F274").schema(); + this.f2750 = readerSchema.getField("F275").schema(); + this.f2760 = readerSchema.getField("F276").schema(); + this.f2770 = readerSchema.getField("F277").schema(); + this.f2780 = readerSchema.getField("F278").schema(); + this.f2790 = readerSchema.getField("F279").schema(); + this.f2800 = readerSchema.getField("F280").schema(); + this.f2810 = readerSchema.getField("F281").schema(); + this.f2820 = readerSchema.getField("F282").schema(); + this.f2830 = readerSchema.getField("F283").schema(); + this.f2840 = readerSchema.getField("F284").schema(); + this.f2850 = readerSchema.getField("F285").schema(); + this.f2860 = readerSchema.getField("F286").schema(); + this.f2870 = readerSchema.getField("F287").schema(); + this.f2880 = readerSchema.getField("F288").schema(); + this.f2890 = readerSchema.getField("F289").schema(); + this.f2900 = readerSchema.getField("F290").schema(); + this.f2910 = readerSchema.getField("F291").schema(); + this.f2920 = readerSchema.getField("F292").schema(); + this.f2930 = readerSchema.getField("F293").schema(); + this.f2940 = readerSchema.getField("F294").schema(); + this.f2950 = readerSchema.getField("F295").schema(); + this.f2960 = readerSchema.getField("F296").schema(); + this.f2970 = readerSchema.getField("F297").schema(); + this.f2980 = readerSchema.getField("F298").schema(); + this.f2990 = readerSchema.getField("F299").schema(); + this.f3000 = readerSchema.getField("F300").schema(); + this.f3010 = readerSchema.getField("F301").schema(); + this.f3020 = readerSchema.getField("F302").schema(); + this.f3030 = readerSchema.getField("F303").schema(); + this.f3040 = readerSchema.getField("F304").schema(); + this.f3050 = readerSchema.getField("F305").schema(); + this.f3060 = readerSchema.getField("F306").schema(); + this.f3070 = readerSchema.getField("F307").schema(); + this.f3080 = readerSchema.getField("F308").schema(); + this.f3090 = readerSchema.getField("F309").schema(); + this.f3100 = readerSchema.getField("F310").schema(); + this.f3110 = readerSchema.getField("F311").schema(); + this.f3120 = readerSchema.getField("F312").schema(); + this.f3130 = readerSchema.getField("F313").schema(); + this.f3140 = readerSchema.getField("F314").schema(); + this.f3150 = readerSchema.getField("F315").schema(); + this.f3160 = readerSchema.getField("F316").schema(); + this.f3170 = readerSchema.getField("F317").schema(); + this.f3180 = readerSchema.getField("F318").schema(); + this.f3190 = readerSchema.getField("F319").schema(); + this.f3200 = readerSchema.getField("F320").schema(); + this.f3210 = readerSchema.getField("F321").schema(); + this.f3220 = readerSchema.getField("F322").schema(); + this.f3230 = readerSchema.getField("F323").schema(); + this.f3240 = readerSchema.getField("F324").schema(); + this.f3250 = readerSchema.getField("F325").schema(); + this.f3260 = readerSchema.getField("F326").schema(); + this.f3270 = readerSchema.getField("F327").schema(); + this.f3280 = readerSchema.getField("F328").schema(); + this.f3290 = readerSchema.getField("F329").schema(); + this.f3300 = readerSchema.getField("F330").schema(); + this.f3310 = readerSchema.getField("F331").schema(); + this.f3320 = readerSchema.getField("F332").schema(); + this.f3330 = readerSchema.getField("F333").schema(); + this.f3340 = readerSchema.getField("F334").schema(); + this.f3350 = readerSchema.getField("F335").schema(); + this.f3360 = readerSchema.getField("F336").schema(); + this.f3370 = readerSchema.getField("F337").schema(); + this.f3380 = readerSchema.getField("F338").schema(); + this.f3390 = readerSchema.getField("F339").schema(); + this.f3400 = readerSchema.getField("F340").schema(); + this.f3410 = readerSchema.getField("F341").schema(); + this.f3420 = readerSchema.getField("F342").schema(); + this.f3430 = readerSchema.getField("F343").schema(); + this.f3440 = readerSchema.getField("F344").schema(); + this.f3450 = readerSchema.getField("F345").schema(); + this.f3460 = readerSchema.getField("F346").schema(); + this.f3470 = readerSchema.getField("F347").schema(); + this.f3480 = readerSchema.getField("F348").schema(); + this.f3490 = readerSchema.getField("F349").schema(); + this.f3500 = readerSchema.getField("F350").schema(); + this.f3510 = readerSchema.getField("F351").schema(); + this.f3520 = readerSchema.getField("F352").schema(); + this.f3530 = readerSchema.getField("F353").schema(); + this.f3540 = readerSchema.getField("F354").schema(); + this.f3550 = readerSchema.getField("F355").schema(); + this.f3560 = readerSchema.getField("F356").schema(); + this.f3570 = readerSchema.getField("F357").schema(); + this.f3580 = readerSchema.getField("F358").schema(); + this.f3590 = readerSchema.getField("F359").schema(); + this.f3600 = readerSchema.getField("F360").schema(); + this.f3610 = readerSchema.getField("F361").schema(); + this.f3620 = readerSchema.getField("F362").schema(); + this.f3630 = readerSchema.getField("F363").schema(); + this.f3640 = readerSchema.getField("F364").schema(); + this.f3650 = readerSchema.getField("F365").schema(); + this.f3660 = readerSchema.getField("F366").schema(); + this.f3670 = readerSchema.getField("F367").schema(); + this.f3680 = readerSchema.getField("F368").schema(); + this.f3690 = readerSchema.getField("F369").schema(); + this.f3700 = readerSchema.getField("F370").schema(); + this.f3710 = readerSchema.getField("F371").schema(); + this.f3720 = readerSchema.getField("F372").schema(); + this.f3730 = readerSchema.getField("F373").schema(); + this.f3740 = readerSchema.getField("F374").schema(); + this.f3750 = readerSchema.getField("F375").schema(); + this.f3760 = readerSchema.getField("F376").schema(); + this.f3770 = readerSchema.getField("F377").schema(); + this.f3780 = readerSchema.getField("F378").schema(); + this.f3790 = readerSchema.getField("F379").schema(); + this.f3800 = readerSchema.getField("F380").schema(); + this.f3810 = readerSchema.getField("F381").schema(); + this.f3820 = readerSchema.getField("F382").schema(); + this.f3830 = readerSchema.getField("F383").schema(); + this.f3840 = readerSchema.getField("F384").schema(); + this.f3850 = readerSchema.getField("F385").schema(); + this.f3860 = readerSchema.getField("F386").schema(); + this.f3870 = readerSchema.getField("F387").schema(); + this.f3880 = readerSchema.getField("F388").schema(); + this.f3890 = readerSchema.getField("F389").schema(); + this.f3900 = readerSchema.getField("F390").schema(); + this.f3910 = readerSchema.getField("F391").schema(); + this.f3920 = readerSchema.getField("F392").schema(); + this.f3930 = readerSchema.getField("F393").schema(); + this.f3940 = readerSchema.getField("F394").schema(); + this.f3950 = readerSchema.getField("F395").schema(); + this.f3960 = readerSchema.getField("F396").schema(); + this.f3970 = readerSchema.getField("F397").schema(); + this.f3980 = readerSchema.getField("F398").schema(); + this.f3990 = readerSchema.getField("F399").schema(); + this.f4000 = readerSchema.getField("F400").schema(); + this.f4010 = readerSchema.getField("F401").schema(); + this.f4020 = readerSchema.getField("F402").schema(); + this.f4030 = readerSchema.getField("F403").schema(); + this.f4040 = readerSchema.getField("F404").schema(); + this.f4050 = readerSchema.getField("F405").schema(); + this.f4060 = readerSchema.getField("F406").schema(); + this.f4070 = readerSchema.getField("F407").schema(); + this.f4080 = readerSchema.getField("F408").schema(); + this.f4090 = readerSchema.getField("F409").schema(); + this.f4100 = readerSchema.getField("F410").schema(); + this.f4110 = readerSchema.getField("F411").schema(); + this.f4120 = readerSchema.getField("F412").schema(); + this.f4130 = readerSchema.getField("F413").schema(); + this.f4140 = readerSchema.getField("F414").schema(); + this.f4150 = readerSchema.getField("F415").schema(); + this.f4160 = readerSchema.getField("F416").schema(); + this.f4170 = readerSchema.getField("F417").schema(); + this.f4180 = readerSchema.getField("F418").schema(); + this.f4190 = readerSchema.getField("F419").schema(); + this.f4200 = readerSchema.getField("F420").schema(); + this.f4210 = readerSchema.getField("F421").schema(); + this.f4220 = readerSchema.getField("F422").schema(); + this.f4230 = readerSchema.getField("F423").schema(); + this.f4240 = readerSchema.getField("F424").schema(); + this.f4250 = readerSchema.getField("F425").schema(); + this.f4260 = readerSchema.getField("F426").schema(); + this.f4270 = readerSchema.getField("F427").schema(); + this.f4280 = readerSchema.getField("F428").schema(); + this.f4290 = readerSchema.getField("F429").schema(); + this.f4300 = readerSchema.getField("F430").schema(); + this.f4310 = readerSchema.getField("F431").schema(); + this.f4320 = readerSchema.getField("F432").schema(); + this.f4330 = readerSchema.getField("F433").schema(); + this.f4340 = readerSchema.getField("F434").schema(); + this.f4350 = readerSchema.getField("F435").schema(); + this.f4360 = readerSchema.getField("F436").schema(); + this.f4370 = readerSchema.getField("F437").schema(); + this.f4380 = readerSchema.getField("F438").schema(); + this.f4390 = readerSchema.getField("F439").schema(); + this.f4400 = readerSchema.getField("F440").schema(); + this.f4410 = readerSchema.getField("F441").schema(); + this.f4420 = readerSchema.getField("F442").schema(); + this.f4430 = readerSchema.getField("F443").schema(); + this.f4440 = readerSchema.getField("F444").schema(); + this.f4450 = readerSchema.getField("F445").schema(); + this.f4460 = readerSchema.getField("F446").schema(); + this.f4470 = readerSchema.getField("F447").schema(); + this.f4480 = readerSchema.getField("F448").schema(); + this.f4490 = readerSchema.getField("F449").schema(); + this.f4500 = readerSchema.getField("F450").schema(); + this.f4510 = readerSchema.getField("F451").schema(); + this.f4520 = readerSchema.getField("F452").schema(); + this.f4530 = readerSchema.getField("F453").schema(); + this.f4540 = readerSchema.getField("F454").schema(); + this.f4550 = readerSchema.getField("F455").schema(); + this.f4560 = readerSchema.getField("F456").schema(); + this.f4570 = readerSchema.getField("F457").schema(); + this.f4580 = readerSchema.getField("F458").schema(); + this.f4590 = readerSchema.getField("F459").schema(); + this.f4600 = readerSchema.getField("F460").schema(); + this.f4610 = readerSchema.getField("F461").schema(); + this.f4620 = readerSchema.getField("F462").schema(); + this.f4630 = readerSchema.getField("F463").schema(); + this.f4640 = readerSchema.getField("F464").schema(); + this.f4650 = readerSchema.getField("F465").schema(); + this.f4660 = readerSchema.getField("F466").schema(); + this.f4670 = readerSchema.getField("F467").schema(); + this.f4680 = readerSchema.getField("F468").schema(); + this.f4690 = readerSchema.getField("F469").schema(); + this.f4700 = readerSchema.getField("F470").schema(); + this.f4710 = readerSchema.getField("F471").schema(); + this.f4720 = readerSchema.getField("F472").schema(); + this.f4730 = readerSchema.getField("F473").schema(); + this.f4740 = readerSchema.getField("F474").schema(); + this.f4750 = readerSchema.getField("F475").schema(); + this.f4760 = readerSchema.getField("F476").schema(); + this.f4770 = readerSchema.getField("F477").schema(); + this.f4780 = readerSchema.getField("F478").schema(); + this.f4790 = readerSchema.getField("F479").schema(); + this.f4800 = readerSchema.getField("F480").schema(); + this.f4810 = readerSchema.getField("F481").schema(); + this.f4820 = readerSchema.getField("F482").schema(); + this.f4830 = readerSchema.getField("F483").schema(); + this.f4840 = readerSchema.getField("F484").schema(); + this.f4850 = readerSchema.getField("F485").schema(); + this.f4860 = readerSchema.getField("F486").schema(); + this.f4870 = readerSchema.getField("F487").schema(); + this.f4880 = readerSchema.getField("F488").schema(); + this.f4890 = readerSchema.getField("F489").schema(); + this.f4900 = readerSchema.getField("F490").schema(); + this.f4910 = readerSchema.getField("F491").schema(); + this.f4920 = readerSchema.getField("F492").schema(); + this.f4930 = readerSchema.getField("F493").schema(); + this.f4940 = readerSchema.getField("F494").schema(); + this.f4950 = readerSchema.getField("F495").schema(); + this.f4960 = readerSchema.getField("F496").schema(); + this.f4970 = readerSchema.getField("F497").schema(); + this.f4980 = readerSchema.getField("F498").schema(); + this.f4990 = readerSchema.getField("F499").schema(); + this.f5000 = readerSchema.getField("F500").schema(); + this.f5010 = readerSchema.getField("F501").schema(); + this.f5020 = readerSchema.getField("F502").schema(); + this.f5030 = readerSchema.getField("F503").schema(); + this.f5040 = readerSchema.getField("F504").schema(); + this.f5050 = readerSchema.getField("F505").schema(); + this.f5060 = readerSchema.getField("F506").schema(); + this.f5070 = readerSchema.getField("F507").schema(); + this.f5080 = readerSchema.getField("F508").schema(); + this.f5090 = readerSchema.getField("F509").schema(); + this.f5100 = readerSchema.getField("F510").schema(); + this.f5110 = readerSchema.getField("F511").schema(); + this.f5120 = readerSchema.getField("F512").schema(); + this.f5130 = readerSchema.getField("F513").schema(); + this.f5140 = readerSchema.getField("F514").schema(); + this.f5150 = readerSchema.getField("F515").schema(); + this.f5160 = readerSchema.getField("F516").schema(); + this.f5170 = readerSchema.getField("F517").schema(); + this.f5180 = readerSchema.getField("F518").schema(); + this.f5190 = readerSchema.getField("F519").schema(); + this.f5200 = readerSchema.getField("F520").schema(); + this.f5210 = readerSchema.getField("F521").schema(); + this.f5220 = readerSchema.getField("F522").schema(); + this.f5230 = readerSchema.getField("F523").schema(); + this.f5240 = readerSchema.getField("F524").schema(); + this.f5250 = readerSchema.getField("F525").schema(); + this.f5260 = readerSchema.getField("F526").schema(); + this.f5270 = readerSchema.getField("F527").schema(); + this.f5280 = readerSchema.getField("F528").schema(); + this.f5290 = readerSchema.getField("F529").schema(); + this.f5300 = readerSchema.getField("F530").schema(); + this.f5310 = readerSchema.getField("F531").schema(); + this.f5320 = readerSchema.getField("F532").schema(); + this.f5330 = readerSchema.getField("F533").schema(); + this.f5340 = readerSchema.getField("F534").schema(); + this.f5350 = readerSchema.getField("F535").schema(); + this.f5360 = readerSchema.getField("F536").schema(); + this.f5370 = readerSchema.getField("F537").schema(); + this.f5380 = readerSchema.getField("F538").schema(); + this.f5390 = readerSchema.getField("F539").schema(); + this.f5400 = readerSchema.getField("F540").schema(); + this.f5410 = readerSchema.getField("F541").schema(); + this.f5420 = readerSchema.getField("F542").schema(); + this.f5430 = readerSchema.getField("F543").schema(); + this.f5440 = readerSchema.getField("F544").schema(); + this.f5450 = readerSchema.getField("F545").schema(); + this.f5460 = readerSchema.getField("F546").schema(); + this.f5470 = readerSchema.getField("F547").schema(); + this.f5480 = readerSchema.getField("F548").schema(); + this.f5490 = readerSchema.getField("F549").schema(); + this.f5500 = readerSchema.getField("F550").schema(); + this.f5510 = readerSchema.getField("F551").schema(); + this.f5520 = readerSchema.getField("F552").schema(); + this.f5530 = readerSchema.getField("F553").schema(); + this.f5540 = readerSchema.getField("F554").schema(); + this.f5550 = readerSchema.getField("F555").schema(); + this.f5560 = readerSchema.getField("F556").schema(); + this.f5570 = readerSchema.getField("F557").schema(); + this.f5580 = readerSchema.getField("F558").schema(); + this.f5590 = readerSchema.getField("F559").schema(); + this.f5600 = readerSchema.getField("F560").schema(); + this.f5610 = readerSchema.getField("F561").schema(); + this.f5620 = readerSchema.getField("F562").schema(); + this.f5630 = readerSchema.getField("F563").schema(); + this.f5640 = readerSchema.getField("F564").schema(); + this.f5650 = readerSchema.getField("F565").schema(); + this.f5660 = readerSchema.getField("F566").schema(); + this.f5670 = readerSchema.getField("F567").schema(); + this.f5680 = readerSchema.getField("F568").schema(); + this.f5690 = readerSchema.getField("F569").schema(); + this.f5700 = readerSchema.getField("F570").schema(); + this.f5710 = readerSchema.getField("F571").schema(); + this.f5720 = readerSchema.getField("F572").schema(); + this.f5730 = readerSchema.getField("F573").schema(); + this.f5740 = readerSchema.getField("F574").schema(); + this.f5750 = readerSchema.getField("F575").schema(); + this.f5760 = readerSchema.getField("F576").schema(); + this.f5770 = readerSchema.getField("F577").schema(); + this.f5780 = readerSchema.getField("F578").schema(); + this.f5790 = readerSchema.getField("F579").schema(); + this.f5800 = readerSchema.getField("F580").schema(); + this.f5810 = readerSchema.getField("F581").schema(); + this.f5820 = readerSchema.getField("F582").schema(); + this.f5830 = readerSchema.getField("F583").schema(); + this.f5840 = readerSchema.getField("F584").schema(); + this.f5850 = readerSchema.getField("F585").schema(); + this.f5860 = readerSchema.getField("F586").schema(); + this.f5870 = readerSchema.getField("F587").schema(); + this.f5880 = readerSchema.getField("F588").schema(); + this.f5890 = readerSchema.getField("F589").schema(); + this.f5900 = readerSchema.getField("F590").schema(); + this.f5910 = readerSchema.getField("F591").schema(); + this.f5920 = readerSchema.getField("F592").schema(); + this.f5930 = readerSchema.getField("F593").schema(); + this.f5940 = readerSchema.getField("F594").schema(); + this.f5950 = readerSchema.getField("F595").schema(); + this.f5960 = readerSchema.getField("F596").schema(); + this.f5970 = readerSchema.getField("F597").schema(); + this.f5980 = readerSchema.getField("F598").schema(); + this.f5990 = readerSchema.getField("F599").schema(); + this.f6000 = readerSchema.getField("F600").schema(); + this.f6010 = readerSchema.getField("F601").schema(); + this.f6020 = readerSchema.getField("F602").schema(); + this.f6030 = readerSchema.getField("F603").schema(); + this.f6040 = readerSchema.getField("F604").schema(); + this.f6050 = readerSchema.getField("F605").schema(); + this.f6060 = readerSchema.getField("F606").schema(); + this.f6070 = readerSchema.getField("F607").schema(); + this.f6080 = readerSchema.getField("F608").schema(); + this.f6090 = readerSchema.getField("F609").schema(); + this.f6100 = readerSchema.getField("F610").schema(); + this.f6110 = readerSchema.getField("F611").schema(); + this.f6120 = readerSchema.getField("F612").schema(); + this.f6130 = readerSchema.getField("F613").schema(); + this.f6140 = readerSchema.getField("F614").schema(); + this.f6150 = readerSchema.getField("F615").schema(); + this.f6160 = readerSchema.getField("F616").schema(); + this.f6170 = readerSchema.getField("F617").schema(); + this.f6180 = readerSchema.getField("F618").schema(); + this.f6190 = readerSchema.getField("F619").schema(); + this.f6200 = readerSchema.getField("F620").schema(); + this.f6210 = readerSchema.getField("F621").schema(); + this.f6220 = readerSchema.getField("F622").schema(); + this.f6230 = readerSchema.getField("F623").schema(); + this.f6240 = readerSchema.getField("F624").schema(); + this.f6250 = readerSchema.getField("F625").schema(); + this.f6260 = readerSchema.getField("F626").schema(); + this.f6270 = readerSchema.getField("F627").schema(); + this.f6280 = readerSchema.getField("F628").schema(); + this.f6290 = readerSchema.getField("F629").schema(); + this.f6300 = readerSchema.getField("F630").schema(); + this.f6310 = readerSchema.getField("F631").schema(); + this.f6320 = readerSchema.getField("F632").schema(); + this.f6330 = readerSchema.getField("F633").schema(); + this.f6340 = readerSchema.getField("F634").schema(); + this.f6350 = readerSchema.getField("F635").schema(); + this.f6360 = readerSchema.getField("F636").schema(); + this.f6370 = readerSchema.getField("F637").schema(); + this.f6380 = readerSchema.getField("F638").schema(); + this.f6390 = readerSchema.getField("F639").schema(); + this.f6400 = readerSchema.getField("F640").schema(); + this.f6410 = readerSchema.getField("F641").schema(); + this.f6420 = readerSchema.getField("F642").schema(); + this.f6430 = readerSchema.getField("F643").schema(); + this.f6440 = readerSchema.getField("F644").schema(); + this.f6450 = readerSchema.getField("F645").schema(); + this.f6460 = readerSchema.getField("F646").schema(); + this.f6470 = readerSchema.getField("F647").schema(); + this.f6480 = readerSchema.getField("F648").schema(); + this.f6490 = readerSchema.getField("F649").schema(); + this.f6500 = readerSchema.getField("F650").schema(); + this.f6510 = readerSchema.getField("F651").schema(); + this.f6520 = readerSchema.getField("F652").schema(); + this.f6530 = readerSchema.getField("F653").schema(); + this.f6540 = readerSchema.getField("F654").schema(); + this.f6550 = readerSchema.getField("F655").schema(); + this.f6560 = readerSchema.getField("F656").schema(); + this.f6570 = readerSchema.getField("F657").schema(); + this.f6580 = readerSchema.getField("F658").schema(); + this.f6590 = readerSchema.getField("F659").schema(); + this.f6600 = readerSchema.getField("F660").schema(); + this.f6610 = readerSchema.getField("F661").schema(); + this.f6620 = readerSchema.getField("F662").schema(); + this.f6630 = readerSchema.getField("F663").schema(); + this.f6640 = readerSchema.getField("F664").schema(); + this.f6650 = readerSchema.getField("F665").schema(); + this.f6660 = readerSchema.getField("F666").schema(); + this.f6670 = readerSchema.getField("F667").schema(); + this.f6680 = readerSchema.getField("F668").schema(); + this.f6690 = readerSchema.getField("F669").schema(); + this.f6700 = readerSchema.getField("F670").schema(); + this.f6710 = readerSchema.getField("F671").schema(); + this.f6720 = readerSchema.getField("F672").schema(); + this.f6730 = readerSchema.getField("F673").schema(); + this.f6740 = readerSchema.getField("F674").schema(); + this.f6750 = readerSchema.getField("F675").schema(); + this.f6760 = readerSchema.getField("F676").schema(); + this.f6770 = readerSchema.getField("F677").schema(); + this.f6780 = readerSchema.getField("F678").schema(); + this.f6790 = readerSchema.getField("F679").schema(); + this.f6800 = readerSchema.getField("F680").schema(); + this.f6810 = readerSchema.getField("F681").schema(); + this.f6820 = readerSchema.getField("F682").schema(); + this.f6830 = readerSchema.getField("F683").schema(); + this.f6840 = readerSchema.getField("F684").schema(); + this.f6850 = readerSchema.getField("F685").schema(); + this.f6860 = readerSchema.getField("F686").schema(); + this.f6870 = readerSchema.getField("F687").schema(); + this.f6880 = readerSchema.getField("F688").schema(); + this.f6890 = readerSchema.getField("F689").schema(); + this.f6900 = readerSchema.getField("F690").schema(); + this.f6910 = readerSchema.getField("F691").schema(); + this.f6920 = readerSchema.getField("F692").schema(); + this.f6930 = readerSchema.getField("F693").schema(); + this.f6940 = readerSchema.getField("F694").schema(); + this.f6950 = readerSchema.getField("F695").schema(); + this.f6960 = readerSchema.getField("F696").schema(); + this.f6970 = readerSchema.getField("F697").schema(); + this.f6980 = readerSchema.getField("F698").schema(); + this.f6990 = readerSchema.getField("F699").schema(); + this.f7000 = readerSchema.getField("F700").schema(); + this.f7010 = readerSchema.getField("F701").schema(); + this.f7020 = readerSchema.getField("F702").schema(); + this.f7030 = readerSchema.getField("F703").schema(); + this.f7040 = readerSchema.getField("F704").schema(); + this.f7050 = readerSchema.getField("F705").schema(); + this.f7060 = readerSchema.getField("F706").schema(); + this.f7070 = readerSchema.getField("F707").schema(); + this.f7080 = readerSchema.getField("F708").schema(); + this.f7090 = readerSchema.getField("F709").schema(); + this.f7100 = readerSchema.getField("F710").schema(); + this.f7110 = readerSchema.getField("F711").schema(); + this.f7120 = readerSchema.getField("F712").schema(); + this.f7130 = readerSchema.getField("F713").schema(); + this.f7140 = readerSchema.getField("F714").schema(); + this.f7150 = readerSchema.getField("F715").schema(); + this.f7160 = readerSchema.getField("F716").schema(); + this.f7170 = readerSchema.getField("F717").schema(); + this.f7180 = readerSchema.getField("F718").schema(); + this.f7190 = readerSchema.getField("F719").schema(); + this.f7200 = readerSchema.getField("F720").schema(); + this.f7210 = readerSchema.getField("F721").schema(); + this.f7220 = readerSchema.getField("F722").schema(); + this.f7230 = readerSchema.getField("F723").schema(); + this.f7240 = readerSchema.getField("F724").schema(); + this.f7250 = readerSchema.getField("F725").schema(); + this.f7260 = readerSchema.getField("F726").schema(); + this.f7270 = readerSchema.getField("F727").schema(); + this.f7280 = readerSchema.getField("F728").schema(); + this.f7290 = readerSchema.getField("F729").schema(); + this.f7300 = readerSchema.getField("F730").schema(); + this.f7310 = readerSchema.getField("F731").schema(); + this.f7320 = readerSchema.getField("F732").schema(); + this.f7330 = readerSchema.getField("F733").schema(); + this.f7340 = readerSchema.getField("F734").schema(); + this.f7350 = readerSchema.getField("F735").schema(); + this.f7360 = readerSchema.getField("F736").schema(); + this.f7370 = readerSchema.getField("F737").schema(); + this.f7380 = readerSchema.getField("F738").schema(); + this.f7390 = readerSchema.getField("F739").schema(); + this.f7400 = readerSchema.getField("F740").schema(); + this.f7410 = readerSchema.getField("F741").schema(); + this.f7420 = readerSchema.getField("F742").schema(); + this.f7430 = readerSchema.getField("F743").schema(); + this.f7440 = readerSchema.getField("F744").schema(); + this.f7450 = readerSchema.getField("F745").schema(); + this.f7460 = readerSchema.getField("F746").schema(); + this.f7470 = readerSchema.getField("F747").schema(); + this.f7480 = readerSchema.getField("F748").schema(); + this.f7490 = readerSchema.getField("F749").schema(); + this.f7500 = readerSchema.getField("F750").schema(); + this.f7510 = readerSchema.getField("F751").schema(); + this.f7520 = readerSchema.getField("F752").schema(); + this.f7530 = readerSchema.getField("F753").schema(); + this.f7540 = readerSchema.getField("F754").schema(); + this.f7550 = readerSchema.getField("F755").schema(); + this.f7560 = readerSchema.getField("F756").schema(); + this.f7570 = readerSchema.getField("F757").schema(); + this.f7580 = readerSchema.getField("F758").schema(); + this.f7590 = readerSchema.getField("F759").schema(); + this.f7600 = readerSchema.getField("F760").schema(); + this.f7610 = readerSchema.getField("F761").schema(); + this.f7620 = readerSchema.getField("F762").schema(); + this.f7630 = readerSchema.getField("F763").schema(); + this.f7640 = readerSchema.getField("F764").schema(); + this.f7650 = readerSchema.getField("F765").schema(); + this.f7660 = readerSchema.getField("F766").schema(); + this.f7670 = readerSchema.getField("F767").schema(); + this.f7680 = readerSchema.getField("F768").schema(); + this.f7690 = readerSchema.getField("F769").schema(); + this.f7700 = readerSchema.getField("F770").schema(); + this.f7710 = readerSchema.getField("F771").schema(); + this.f7720 = readerSchema.getField("F772").schema(); + this.f7730 = readerSchema.getField("F773").schema(); + this.f7740 = readerSchema.getField("F774").schema(); + this.f7750 = readerSchema.getField("F775").schema(); + this.f7760 = readerSchema.getField("F776").schema(); + this.f7770 = readerSchema.getField("F777").schema(); + this.f7780 = readerSchema.getField("F778").schema(); + this.f7790 = readerSchema.getField("F779").schema(); + this.f7800 = readerSchema.getField("F780").schema(); + this.f7810 = readerSchema.getField("F781").schema(); + this.f7820 = readerSchema.getField("F782").schema(); + this.f7830 = readerSchema.getField("F783").schema(); + this.f7840 = readerSchema.getField("F784").schema(); + this.f7850 = readerSchema.getField("F785").schema(); + this.f7860 = readerSchema.getField("F786").schema(); + this.f7870 = readerSchema.getField("F787").schema(); + this.f7880 = readerSchema.getField("F788").schema(); + this.f7890 = readerSchema.getField("F789").schema(); + this.f7900 = readerSchema.getField("F790").schema(); + this.f7910 = readerSchema.getField("F791").schema(); + this.f7920 = readerSchema.getField("F792").schema(); + this.f7930 = readerSchema.getField("F793").schema(); + this.f7940 = readerSchema.getField("F794").schema(); + this.f7950 = readerSchema.getField("F795").schema(); + this.f7960 = readerSchema.getField("F796").schema(); + this.f7970 = readerSchema.getField("F797").schema(); + this.f7980 = readerSchema.getField("F798").schema(); + this.f7990 = readerSchema.getField("F799").schema(); + this.f8000 = readerSchema.getField("F800").schema(); + this.f8010 = readerSchema.getField("F801").schema(); + this.f8020 = readerSchema.getField("F802").schema(); + this.f8030 = readerSchema.getField("F803").schema(); + this.f8040 = readerSchema.getField("F804").schema(); + this.f8050 = readerSchema.getField("F805").schema(); + this.f8060 = readerSchema.getField("F806").schema(); + this.f8070 = readerSchema.getField("F807").schema(); + this.f8080 = readerSchema.getField("F808").schema(); + this.f8090 = readerSchema.getField("F809").schema(); + this.f8100 = readerSchema.getField("F810").schema(); + this.f8110 = readerSchema.getField("F811").schema(); + this.f8120 = readerSchema.getField("F812").schema(); + this.f8130 = readerSchema.getField("F813").schema(); + this.f8140 = readerSchema.getField("F814").schema(); + this.f8150 = readerSchema.getField("F815").schema(); + this.f8160 = readerSchema.getField("F816").schema(); + this.f8170 = readerSchema.getField("F817").schema(); + this.f8180 = readerSchema.getField("F818").schema(); + this.f8190 = readerSchema.getField("F819").schema(); + this.f8200 = readerSchema.getField("F820").schema(); + this.f8210 = readerSchema.getField("F821").schema(); + this.f8220 = readerSchema.getField("F822").schema(); + this.f8230 = readerSchema.getField("F823").schema(); + this.f8240 = readerSchema.getField("F824").schema(); + this.f8250 = readerSchema.getField("F825").schema(); + this.f8260 = readerSchema.getField("F826").schema(); + this.f8270 = readerSchema.getField("F827").schema(); + this.f8280 = readerSchema.getField("F828").schema(); + this.f8290 = readerSchema.getField("F829").schema(); + this.f8300 = readerSchema.getField("F830").schema(); + this.f8310 = readerSchema.getField("F831").schema(); + this.f8320 = readerSchema.getField("F832").schema(); + this.f8330 = readerSchema.getField("F833").schema(); + this.f8340 = readerSchema.getField("F834").schema(); + this.f8350 = readerSchema.getField("F835").schema(); + this.f8360 = readerSchema.getField("F836").schema(); + this.f8370 = readerSchema.getField("F837").schema(); + this.f8380 = readerSchema.getField("F838").schema(); + this.f8390 = readerSchema.getField("F839").schema(); + this.f8400 = readerSchema.getField("F840").schema(); + this.f8410 = readerSchema.getField("F841").schema(); + this.f8420 = readerSchema.getField("F842").schema(); + this.f8430 = readerSchema.getField("F843").schema(); + this.f8440 = readerSchema.getField("F844").schema(); + this.f8450 = readerSchema.getField("F845").schema(); + this.f8460 = readerSchema.getField("F846").schema(); + this.f8470 = readerSchema.getField("F847").schema(); + this.f8480 = readerSchema.getField("F848").schema(); + this.f8490 = readerSchema.getField("F849").schema(); + this.f8500 = readerSchema.getField("F850").schema(); + this.f8510 = readerSchema.getField("F851").schema(); + this.f8520 = readerSchema.getField("F852").schema(); + this.f8530 = readerSchema.getField("F853").schema(); + this.f8540 = readerSchema.getField("F854").schema(); + this.f8550 = readerSchema.getField("F855").schema(); + this.f8560 = readerSchema.getField("F856").schema(); + this.f8570 = readerSchema.getField("F857").schema(); + this.f8580 = readerSchema.getField("F858").schema(); + this.f8590 = readerSchema.getField("F859").schema(); + this.f8600 = readerSchema.getField("F860").schema(); + this.f8610 = readerSchema.getField("F861").schema(); + this.f8620 = readerSchema.getField("F862").schema(); + this.f8630 = readerSchema.getField("F863").schema(); + this.f8640 = readerSchema.getField("F864").schema(); + this.f8650 = readerSchema.getField("F865").schema(); + this.f8660 = readerSchema.getField("F866").schema(); + this.f8670 = readerSchema.getField("F867").schema(); + this.f8680 = readerSchema.getField("F868").schema(); + this.f8690 = readerSchema.getField("F869").schema(); + this.f8700 = readerSchema.getField("F870").schema(); + this.f8710 = readerSchema.getField("F871").schema(); + this.f8720 = readerSchema.getField("F872").schema(); + this.f8730 = readerSchema.getField("F873").schema(); + this.f8740 = readerSchema.getField("F874").schema(); + this.f8750 = readerSchema.getField("F875").schema(); + this.f8760 = readerSchema.getField("F876").schema(); + this.f8770 = readerSchema.getField("F877").schema(); + this.f8780 = readerSchema.getField("F878").schema(); + this.f8790 = readerSchema.getField("F879").schema(); + this.f8800 = readerSchema.getField("F880").schema(); + this.f8810 = readerSchema.getField("F881").schema(); + this.f8820 = readerSchema.getField("F882").schema(); + this.f8830 = readerSchema.getField("F883").schema(); + this.f8840 = readerSchema.getField("F884").schema(); + this.f8850 = readerSchema.getField("F885").schema(); + this.f8860 = readerSchema.getField("F886").schema(); + this.f8870 = readerSchema.getField("F887").schema(); + this.f8880 = readerSchema.getField("F888").schema(); + this.f8890 = readerSchema.getField("F889").schema(); + this.f8900 = readerSchema.getField("F890").schema(); + this.f8910 = readerSchema.getField("F891").schema(); + this.f8920 = readerSchema.getField("F892").schema(); + this.f8930 = readerSchema.getField("F893").schema(); + this.f8940 = readerSchema.getField("F894").schema(); + this.f8950 = readerSchema.getField("F895").schema(); + this.f8960 = readerSchema.getField("F896").schema(); + this.f8970 = readerSchema.getField("F897").schema(); + this.f8980 = readerSchema.getField("F898").schema(); + this.f8990 = readerSchema.getField("F899").schema(); + this.f9000 = readerSchema.getField("F900").schema(); + this.f9010 = readerSchema.getField("F901").schema(); + this.f9020 = readerSchema.getField("F902").schema(); + this.f9030 = readerSchema.getField("F903").schema(); + this.f9040 = readerSchema.getField("F904").schema(); + this.f9050 = readerSchema.getField("F905").schema(); + this.f9060 = readerSchema.getField("F906").schema(); + this.f9070 = readerSchema.getField("F907").schema(); + this.f9080 = readerSchema.getField("F908").schema(); + this.f9090 = readerSchema.getField("F909").schema(); + this.f9100 = readerSchema.getField("F910").schema(); + this.f9110 = readerSchema.getField("F911").schema(); + this.f9120 = readerSchema.getField("F912").schema(); + this.f9130 = readerSchema.getField("F913").schema(); + this.f9140 = readerSchema.getField("F914").schema(); + this.f9150 = readerSchema.getField("F915").schema(); + this.f9160 = readerSchema.getField("F916").schema(); + this.f9170 = readerSchema.getField("F917").schema(); + this.f9180 = readerSchema.getField("F918").schema(); + this.f9190 = readerSchema.getField("F919").schema(); + this.f9200 = readerSchema.getField("F920").schema(); + this.f9210 = readerSchema.getField("F921").schema(); + this.f9220 = readerSchema.getField("F922").schema(); + this.f9230 = readerSchema.getField("F923").schema(); + this.f9240 = readerSchema.getField("F924").schema(); + this.f9250 = readerSchema.getField("F925").schema(); + this.f9260 = readerSchema.getField("F926").schema(); + this.f9270 = readerSchema.getField("F927").schema(); + this.f9280 = readerSchema.getField("F928").schema(); + this.f9290 = readerSchema.getField("F929").schema(); + this.f9300 = readerSchema.getField("F930").schema(); + this.f9310 = readerSchema.getField("F931").schema(); + this.f9320 = readerSchema.getField("F932").schema(); + this.f9330 = readerSchema.getField("F933").schema(); + this.f9340 = readerSchema.getField("F934").schema(); + this.f9350 = readerSchema.getField("F935").schema(); + this.f9360 = readerSchema.getField("F936").schema(); + this.f9370 = readerSchema.getField("F937").schema(); + this.f9380 = readerSchema.getField("F938").schema(); + this.f9390 = readerSchema.getField("F939").schema(); + this.f9400 = readerSchema.getField("F940").schema(); + this.f9410 = readerSchema.getField("F941").schema(); + this.f9420 = readerSchema.getField("F942").schema(); + this.f9430 = readerSchema.getField("F943").schema(); + this.f9440 = readerSchema.getField("F944").schema(); + this.f9450 = readerSchema.getField("F945").schema(); + this.f9460 = readerSchema.getField("F946").schema(); + this.f9470 = readerSchema.getField("F947").schema(); + this.f9480 = readerSchema.getField("F948").schema(); + this.f9490 = readerSchema.getField("F949").schema(); + this.f9500 = readerSchema.getField("F950").schema(); + this.f9510 = readerSchema.getField("F951").schema(); + this.f9520 = readerSchema.getField("F952").schema(); + this.f9530 = readerSchema.getField("F953").schema(); + this.f9540 = readerSchema.getField("F954").schema(); + this.f9550 = readerSchema.getField("F955").schema(); + this.f9560 = readerSchema.getField("F956").schema(); + this.f9570 = readerSchema.getField("F957").schema(); + this.f9580 = readerSchema.getField("F958").schema(); + this.f9590 = readerSchema.getField("F959").schema(); + this.f9600 = readerSchema.getField("F960").schema(); + this.f9610 = readerSchema.getField("F961").schema(); + this.f9620 = readerSchema.getField("F962").schema(); + this.f9630 = readerSchema.getField("F963").schema(); + this.f9640 = readerSchema.getField("F964").schema(); + this.f9650 = readerSchema.getField("F965").schema(); + this.f9660 = readerSchema.getField("F966").schema(); + this.f9670 = readerSchema.getField("F967").schema(); + this.f9680 = readerSchema.getField("F968").schema(); + this.f9690 = readerSchema.getField("F969").schema(); + this.f9700 = readerSchema.getField("F970").schema(); + this.f9710 = readerSchema.getField("F971").schema(); + this.f9720 = readerSchema.getField("F972").schema(); + this.f9730 = readerSchema.getField("F973").schema(); + this.f9740 = readerSchema.getField("F974").schema(); + this.f9750 = readerSchema.getField("F975").schema(); + this.f9760 = readerSchema.getField("F976").schema(); + this.f9770 = readerSchema.getField("F977").schema(); + this.f9780 = readerSchema.getField("F978").schema(); + this.f9790 = readerSchema.getField("F979").schema(); + this.f9800 = readerSchema.getField("F980").schema(); + this.f9810 = readerSchema.getField("F981").schema(); + this.f9820 = readerSchema.getField("F982").schema(); + this.f9830 = readerSchema.getField("F983").schema(); + this.f9840 = readerSchema.getField("F984").schema(); + this.f9850 = readerSchema.getField("F985").schema(); + this.f9860 = readerSchema.getField("F986").schema(); + this.f9870 = readerSchema.getField("F987").schema(); + this.f9880 = readerSchema.getField("F988").schema(); + this.f9890 = readerSchema.getField("F989").schema(); + this.f9900 = readerSchema.getField("F990").schema(); + this.f9910 = readerSchema.getField("F991").schema(); + this.f9920 = readerSchema.getField("F992").schema(); + this.f9930 = readerSchema.getField("F993").schema(); + this.f9940 = readerSchema.getField("F994").schema(); + this.f9950 = readerSchema.getField("F995").schema(); + this.f9960 = readerSchema.getField("F996").schema(); + this.f9970 = readerSchema.getField("F997").schema(); + this.f9980 = readerSchema.getField("F998").schema(); + this.f9990 = readerSchema.getField("F999").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'F0': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(1, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'F1': "+ unionIndex1)); + } + } + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(2, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence2; + Object oldString2 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(2); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(2, charSequence2); + } else { + throw new RuntimeException(("Illegal union index for 'F2': "+ unionIndex2)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(3, null); + } else { + if (unionIndex3 == 1) { + Utf8 charSequence3; + Object oldString3 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(3); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(3, charSequence3); + } else { + throw new RuntimeException(("Illegal union index for 'F3': "+ unionIndex3)); + } + } + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(4, null); + } else { + if (unionIndex4 == 1) { + Utf8 charSequence4; + Object oldString4 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(4); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(4, charSequence4); + } else { + throw new RuntimeException(("Illegal union index for 'F4': "+ unionIndex4)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(5, null); + } else { + if (unionIndex5 == 1) { + Utf8 charSequence5; + Object oldString5 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(5); + if (oldString5 instanceof Utf8) { + charSequence5 = (decoder).readString(((Utf8) oldString5)); + } else { + charSequence5 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(5, charSequence5); + } else { + throw new RuntimeException(("Illegal union index for 'F5': "+ unionIndex5)); + } + } + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(6, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence6; + Object oldString6 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(6); + if (oldString6 instanceof Utf8) { + charSequence6 = (decoder).readString(((Utf8) oldString6)); + } else { + charSequence6 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(6, charSequence6); + } else { + throw new RuntimeException(("Illegal union index for 'F6': "+ unionIndex6)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(7, null); + } else { + if (unionIndex7 == 1) { + Utf8 charSequence7; + Object oldString7 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(7); + if (oldString7 instanceof Utf8) { + charSequence7 = (decoder).readString(((Utf8) oldString7)); + } else { + charSequence7 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(7, charSequence7); + } else { + throw new RuntimeException(("Illegal union index for 'F7': "+ unionIndex7)); + } + } + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(8, null); + } else { + if (unionIndex8 == 1) { + Utf8 charSequence8; + Object oldString8 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(8); + if (oldString8 instanceof Utf8) { + charSequence8 = (decoder).readString(((Utf8) oldString8)); + } else { + charSequence8 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(8, charSequence8); + } else { + throw new RuntimeException(("Illegal union index for 'F8': "+ unionIndex8)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex9 = (decoder.readIndex()); + if (unionIndex9 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(9, null); + } else { + if (unionIndex9 == 1) { + Utf8 charSequence9; + Object oldString9 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(9); + if (oldString9 instanceof Utf8) { + charSequence9 = (decoder).readString(((Utf8) oldString9)); + } else { + charSequence9 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(9, charSequence9); + } else { + throw new RuntimeException(("Illegal union index for 'F9': "+ unionIndex9)); + } + } + int unionIndex10 = (decoder.readIndex()); + if (unionIndex10 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(10, null); + } else { + if (unionIndex10 == 1) { + Utf8 charSequence10; + Object oldString10 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(10); + if (oldString10 instanceof Utf8) { + charSequence10 = (decoder).readString(((Utf8) oldString10)); + } else { + charSequence10 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(10, charSequence10); + } else { + throw new RuntimeException(("Illegal union index for 'F10': "+ unionIndex10)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex11 = (decoder.readIndex()); + if (unionIndex11 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(11, null); + } else { + if (unionIndex11 == 1) { + Utf8 charSequence11; + Object oldString11 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(11); + if (oldString11 instanceof Utf8) { + charSequence11 = (decoder).readString(((Utf8) oldString11)); + } else { + charSequence11 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(11, charSequence11); + } else { + throw new RuntimeException(("Illegal union index for 'F11': "+ unionIndex11)); + } + } + int unionIndex12 = (decoder.readIndex()); + if (unionIndex12 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(12, null); + } else { + if (unionIndex12 == 1) { + Utf8 charSequence12; + Object oldString12 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(12); + if (oldString12 instanceof Utf8) { + charSequence12 = (decoder).readString(((Utf8) oldString12)); + } else { + charSequence12 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(12, charSequence12); + } else { + throw new RuntimeException(("Illegal union index for 'F12': "+ unionIndex12)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex13 = (decoder.readIndex()); + if (unionIndex13 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(13, null); + } else { + if (unionIndex13 == 1) { + Utf8 charSequence13; + Object oldString13 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(13); + if (oldString13 instanceof Utf8) { + charSequence13 = (decoder).readString(((Utf8) oldString13)); + } else { + charSequence13 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(13, charSequence13); + } else { + throw new RuntimeException(("Illegal union index for 'F13': "+ unionIndex13)); + } + } + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(14, null); + } else { + if (unionIndex14 == 1) { + Utf8 charSequence14; + Object oldString14 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(14); + if (oldString14 instanceof Utf8) { + charSequence14 = (decoder).readString(((Utf8) oldString14)); + } else { + charSequence14 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(14, charSequence14); + } else { + throw new RuntimeException(("Illegal union index for 'F14': "+ unionIndex14)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(15, null); + } else { + if (unionIndex15 == 1) { + Utf8 charSequence15; + Object oldString15 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(15); + if (oldString15 instanceof Utf8) { + charSequence15 = (decoder).readString(((Utf8) oldString15)); + } else { + charSequence15 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(15, charSequence15); + } else { + throw new RuntimeException(("Illegal union index for 'F15': "+ unionIndex15)); + } + } + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(16, null); + } else { + if (unionIndex16 == 1) { + Utf8 charSequence16; + Object oldString16 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(16); + if (oldString16 instanceof Utf8) { + charSequence16 = (decoder).readString(((Utf8) oldString16)); + } else { + charSequence16 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(16, charSequence16); + } else { + throw new RuntimeException(("Illegal union index for 'F16': "+ unionIndex16)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex17 = (decoder.readIndex()); + if (unionIndex17 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(17, null); + } else { + if (unionIndex17 == 1) { + Utf8 charSequence17; + Object oldString17 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(17); + if (oldString17 instanceof Utf8) { + charSequence17 = (decoder).readString(((Utf8) oldString17)); + } else { + charSequence17 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(17, charSequence17); + } else { + throw new RuntimeException(("Illegal union index for 'F17': "+ unionIndex17)); + } + } + int unionIndex18 = (decoder.readIndex()); + if (unionIndex18 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(18, null); + } else { + if (unionIndex18 == 1) { + Utf8 charSequence18; + Object oldString18 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(18); + if (oldString18 instanceof Utf8) { + charSequence18 = (decoder).readString(((Utf8) oldString18)); + } else { + charSequence18 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(18, charSequence18); + } else { + throw new RuntimeException(("Illegal union index for 'F18': "+ unionIndex18)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex19 = (decoder.readIndex()); + if (unionIndex19 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(19, null); + } else { + if (unionIndex19 == 1) { + Utf8 charSequence19; + Object oldString19 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(19); + if (oldString19 instanceof Utf8) { + charSequence19 = (decoder).readString(((Utf8) oldString19)); + } else { + charSequence19 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(19, charSequence19); + } else { + throw new RuntimeException(("Illegal union index for 'F19': "+ unionIndex19)); + } + } + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(20, null); + } else { + if (unionIndex20 == 1) { + Utf8 charSequence20; + Object oldString20 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(20); + if (oldString20 instanceof Utf8) { + charSequence20 = (decoder).readString(((Utf8) oldString20)); + } else { + charSequence20 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(20, charSequence20); + } else { + throw new RuntimeException(("Illegal union index for 'F20': "+ unionIndex20)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(21, null); + } else { + if (unionIndex21 == 1) { + Utf8 charSequence21; + Object oldString21 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(21); + if (oldString21 instanceof Utf8) { + charSequence21 = (decoder).readString(((Utf8) oldString21)); + } else { + charSequence21 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(21, charSequence21); + } else { + throw new RuntimeException(("Illegal union index for 'F21': "+ unionIndex21)); + } + } + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(22, null); + } else { + if (unionIndex22 == 1) { + Utf8 charSequence22; + Object oldString22 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(22); + if (oldString22 instanceof Utf8) { + charSequence22 = (decoder).readString(((Utf8) oldString22)); + } else { + charSequence22 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(22, charSequence22); + } else { + throw new RuntimeException(("Illegal union index for 'F22': "+ unionIndex22)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(23, null); + } else { + if (unionIndex23 == 1) { + Utf8 charSequence23; + Object oldString23 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(23); + if (oldString23 instanceof Utf8) { + charSequence23 = (decoder).readString(((Utf8) oldString23)); + } else { + charSequence23 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(23, charSequence23); + } else { + throw new RuntimeException(("Illegal union index for 'F23': "+ unionIndex23)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(24, null); + } else { + if (unionIndex24 == 1) { + Utf8 charSequence24; + Object oldString24 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(24); + if (oldString24 instanceof Utf8) { + charSequence24 = (decoder).readString(((Utf8) oldString24)); + } else { + charSequence24 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(24, charSequence24); + } else { + throw new RuntimeException(("Illegal union index for 'F24': "+ unionIndex24)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(25, null); + } else { + if (unionIndex25 == 1) { + Utf8 charSequence25; + Object oldString25 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(25); + if (oldString25 instanceof Utf8) { + charSequence25 = (decoder).readString(((Utf8) oldString25)); + } else { + charSequence25 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(25, charSequence25); + } else { + throw new RuntimeException(("Illegal union index for 'F25': "+ unionIndex25)); + } + } + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(26, null); + } else { + if (unionIndex26 == 1) { + Utf8 charSequence26; + Object oldString26 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(26); + if (oldString26 instanceof Utf8) { + charSequence26 = (decoder).readString(((Utf8) oldString26)); + } else { + charSequence26 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(26, charSequence26); + } else { + throw new RuntimeException(("Illegal union index for 'F26': "+ unionIndex26)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex27 = (decoder.readIndex()); + if (unionIndex27 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(27, null); + } else { + if (unionIndex27 == 1) { + Utf8 charSequence27; + Object oldString27 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(27); + if (oldString27 instanceof Utf8) { + charSequence27 = (decoder).readString(((Utf8) oldString27)); + } else { + charSequence27 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(27, charSequence27); + } else { + throw new RuntimeException(("Illegal union index for 'F27': "+ unionIndex27)); + } + } + int unionIndex28 = (decoder.readIndex()); + if (unionIndex28 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(28, null); + } else { + if (unionIndex28 == 1) { + Utf8 charSequence28; + Object oldString28 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(28); + if (oldString28 instanceof Utf8) { + charSequence28 = (decoder).readString(((Utf8) oldString28)); + } else { + charSequence28 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(28, charSequence28); + } else { + throw new RuntimeException(("Illegal union index for 'F28': "+ unionIndex28)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex29 = (decoder.readIndex()); + if (unionIndex29 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(29, null); + } else { + if (unionIndex29 == 1) { + Utf8 charSequence29; + Object oldString29 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(29); + if (oldString29 instanceof Utf8) { + charSequence29 = (decoder).readString(((Utf8) oldString29)); + } else { + charSequence29 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(29, charSequence29); + } else { + throw new RuntimeException(("Illegal union index for 'F29': "+ unionIndex29)); + } + } + int unionIndex30 = (decoder.readIndex()); + if (unionIndex30 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(30, null); + } else { + if (unionIndex30 == 1) { + Utf8 charSequence30; + Object oldString30 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(30); + if (oldString30 instanceof Utf8) { + charSequence30 = (decoder).readString(((Utf8) oldString30)); + } else { + charSequence30 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(30, charSequence30); + } else { + throw new RuntimeException(("Illegal union index for 'F30': "+ unionIndex30)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex31 = (decoder.readIndex()); + if (unionIndex31 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(31, null); + } else { + if (unionIndex31 == 1) { + Utf8 charSequence31; + Object oldString31 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(31); + if (oldString31 instanceof Utf8) { + charSequence31 = (decoder).readString(((Utf8) oldString31)); + } else { + charSequence31 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(31, charSequence31); + } else { + throw new RuntimeException(("Illegal union index for 'F31': "+ unionIndex31)); + } + } + int unionIndex32 = (decoder.readIndex()); + if (unionIndex32 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(32, null); + } else { + if (unionIndex32 == 1) { + Utf8 charSequence32; + Object oldString32 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(32); + if (oldString32 instanceof Utf8) { + charSequence32 = (decoder).readString(((Utf8) oldString32)); + } else { + charSequence32 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(32, charSequence32); + } else { + throw new RuntimeException(("Illegal union index for 'F32': "+ unionIndex32)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex33 = (decoder.readIndex()); + if (unionIndex33 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(33, null); + } else { + if (unionIndex33 == 1) { + Utf8 charSequence33; + Object oldString33 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(33); + if (oldString33 instanceof Utf8) { + charSequence33 = (decoder).readString(((Utf8) oldString33)); + } else { + charSequence33 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(33, charSequence33); + } else { + throw new RuntimeException(("Illegal union index for 'F33': "+ unionIndex33)); + } + } + int unionIndex34 = (decoder.readIndex()); + if (unionIndex34 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(34, null); + } else { + if (unionIndex34 == 1) { + Utf8 charSequence34; + Object oldString34 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(34); + if (oldString34 instanceof Utf8) { + charSequence34 = (decoder).readString(((Utf8) oldString34)); + } else { + charSequence34 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(34, charSequence34); + } else { + throw new RuntimeException(("Illegal union index for 'F34': "+ unionIndex34)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex35 = (decoder.readIndex()); + if (unionIndex35 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(35, null); + } else { + if (unionIndex35 == 1) { + Utf8 charSequence35; + Object oldString35 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(35); + if (oldString35 instanceof Utf8) { + charSequence35 = (decoder).readString(((Utf8) oldString35)); + } else { + charSequence35 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(35, charSequence35); + } else { + throw new RuntimeException(("Illegal union index for 'F35': "+ unionIndex35)); + } + } + int unionIndex36 = (decoder.readIndex()); + if (unionIndex36 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(36, null); + } else { + if (unionIndex36 == 1) { + Utf8 charSequence36; + Object oldString36 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(36); + if (oldString36 instanceof Utf8) { + charSequence36 = (decoder).readString(((Utf8) oldString36)); + } else { + charSequence36 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(36, charSequence36); + } else { + throw new RuntimeException(("Illegal union index for 'F36': "+ unionIndex36)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex37 = (decoder.readIndex()); + if (unionIndex37 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(37, null); + } else { + if (unionIndex37 == 1) { + Utf8 charSequence37; + Object oldString37 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(37); + if (oldString37 instanceof Utf8) { + charSequence37 = (decoder).readString(((Utf8) oldString37)); + } else { + charSequence37 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(37, charSequence37); + } else { + throw new RuntimeException(("Illegal union index for 'F37': "+ unionIndex37)); + } + } + int unionIndex38 = (decoder.readIndex()); + if (unionIndex38 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(38, null); + } else { + if (unionIndex38 == 1) { + Utf8 charSequence38; + Object oldString38 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(38); + if (oldString38 instanceof Utf8) { + charSequence38 = (decoder).readString(((Utf8) oldString38)); + } else { + charSequence38 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(38, charSequence38); + } else { + throw new RuntimeException(("Illegal union index for 'F38': "+ unionIndex38)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex39 = (decoder.readIndex()); + if (unionIndex39 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(39, null); + } else { + if (unionIndex39 == 1) { + Utf8 charSequence39; + Object oldString39 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(39); + if (oldString39 instanceof Utf8) { + charSequence39 = (decoder).readString(((Utf8) oldString39)); + } else { + charSequence39 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(39, charSequence39); + } else { + throw new RuntimeException(("Illegal union index for 'F39': "+ unionIndex39)); + } + } + int unionIndex40 = (decoder.readIndex()); + if (unionIndex40 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(40, null); + } else { + if (unionIndex40 == 1) { + Utf8 charSequence40; + Object oldString40 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(40); + if (oldString40 instanceof Utf8) { + charSequence40 = (decoder).readString(((Utf8) oldString40)); + } else { + charSequence40 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(40, charSequence40); + } else { + throw new RuntimeException(("Illegal union index for 'F40': "+ unionIndex40)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex41 = (decoder.readIndex()); + if (unionIndex41 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(41, null); + } else { + if (unionIndex41 == 1) { + Utf8 charSequence41; + Object oldString41 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(41); + if (oldString41 instanceof Utf8) { + charSequence41 = (decoder).readString(((Utf8) oldString41)); + } else { + charSequence41 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(41, charSequence41); + } else { + throw new RuntimeException(("Illegal union index for 'F41': "+ unionIndex41)); + } + } + int unionIndex42 = (decoder.readIndex()); + if (unionIndex42 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(42, null); + } else { + if (unionIndex42 == 1) { + Utf8 charSequence42; + Object oldString42 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(42); + if (oldString42 instanceof Utf8) { + charSequence42 = (decoder).readString(((Utf8) oldString42)); + } else { + charSequence42 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(42, charSequence42); + } else { + throw new RuntimeException(("Illegal union index for 'F42': "+ unionIndex42)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex43 = (decoder.readIndex()); + if (unionIndex43 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(43, null); + } else { + if (unionIndex43 == 1) { + Utf8 charSequence43; + Object oldString43 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(43); + if (oldString43 instanceof Utf8) { + charSequence43 = (decoder).readString(((Utf8) oldString43)); + } else { + charSequence43 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(43, charSequence43); + } else { + throw new RuntimeException(("Illegal union index for 'F43': "+ unionIndex43)); + } + } + int unionIndex44 = (decoder.readIndex()); + if (unionIndex44 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(44, null); + } else { + if (unionIndex44 == 1) { + Utf8 charSequence44; + Object oldString44 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(44); + if (oldString44 instanceof Utf8) { + charSequence44 = (decoder).readString(((Utf8) oldString44)); + } else { + charSequence44 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(44, charSequence44); + } else { + throw new RuntimeException(("Illegal union index for 'F44': "+ unionIndex44)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex45 = (decoder.readIndex()); + if (unionIndex45 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(45, null); + } else { + if (unionIndex45 == 1) { + Utf8 charSequence45; + Object oldString45 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(45); + if (oldString45 instanceof Utf8) { + charSequence45 = (decoder).readString(((Utf8) oldString45)); + } else { + charSequence45 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(45, charSequence45); + } else { + throw new RuntimeException(("Illegal union index for 'F45': "+ unionIndex45)); + } + } + int unionIndex46 = (decoder.readIndex()); + if (unionIndex46 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(46, null); + } else { + if (unionIndex46 == 1) { + Utf8 charSequence46; + Object oldString46 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(46); + if (oldString46 instanceof Utf8) { + charSequence46 = (decoder).readString(((Utf8) oldString46)); + } else { + charSequence46 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(46, charSequence46); + } else { + throw new RuntimeException(("Illegal union index for 'F46': "+ unionIndex46)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex47 = (decoder.readIndex()); + if (unionIndex47 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(47, null); + } else { + if (unionIndex47 == 1) { + Utf8 charSequence47; + Object oldString47 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(47); + if (oldString47 instanceof Utf8) { + charSequence47 = (decoder).readString(((Utf8) oldString47)); + } else { + charSequence47 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(47, charSequence47); + } else { + throw new RuntimeException(("Illegal union index for 'F47': "+ unionIndex47)); + } + } + int unionIndex48 = (decoder.readIndex()); + if (unionIndex48 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(48, null); + } else { + if (unionIndex48 == 1) { + Utf8 charSequence48; + Object oldString48 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(48); + if (oldString48 instanceof Utf8) { + charSequence48 = (decoder).readString(((Utf8) oldString48)); + } else { + charSequence48 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(48, charSequence48); + } else { + throw new RuntimeException(("Illegal union index for 'F48': "+ unionIndex48)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex49 = (decoder.readIndex()); + if (unionIndex49 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(49, null); + } else { + if (unionIndex49 == 1) { + Utf8 charSequence49; + Object oldString49 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(49); + if (oldString49 instanceof Utf8) { + charSequence49 = (decoder).readString(((Utf8) oldString49)); + } else { + charSequence49 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(49, charSequence49); + } else { + throw new RuntimeException(("Illegal union index for 'F49': "+ unionIndex49)); + } + } + int unionIndex50 = (decoder.readIndex()); + if (unionIndex50 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(50, null); + } else { + if (unionIndex50 == 1) { + Utf8 charSequence50; + Object oldString50 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(50); + if (oldString50 instanceof Utf8) { + charSequence50 = (decoder).readString(((Utf8) oldString50)); + } else { + charSequence50 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(50, charSequence50); + } else { + throw new RuntimeException(("Illegal union index for 'F50': "+ unionIndex50)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex51 = (decoder.readIndex()); + if (unionIndex51 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(51, null); + } else { + if (unionIndex51 == 1) { + Utf8 charSequence51; + Object oldString51 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(51); + if (oldString51 instanceof Utf8) { + charSequence51 = (decoder).readString(((Utf8) oldString51)); + } else { + charSequence51 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(51, charSequence51); + } else { + throw new RuntimeException(("Illegal union index for 'F51': "+ unionIndex51)); + } + } + int unionIndex52 = (decoder.readIndex()); + if (unionIndex52 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(52, null); + } else { + if (unionIndex52 == 1) { + Utf8 charSequence52; + Object oldString52 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(52); + if (oldString52 instanceof Utf8) { + charSequence52 = (decoder).readString(((Utf8) oldString52)); + } else { + charSequence52 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(52, charSequence52); + } else { + throw new RuntimeException(("Illegal union index for 'F52': "+ unionIndex52)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex53 = (decoder.readIndex()); + if (unionIndex53 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(53, null); + } else { + if (unionIndex53 == 1) { + Utf8 charSequence53; + Object oldString53 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(53); + if (oldString53 instanceof Utf8) { + charSequence53 = (decoder).readString(((Utf8) oldString53)); + } else { + charSequence53 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(53, charSequence53); + } else { + throw new RuntimeException(("Illegal union index for 'F53': "+ unionIndex53)); + } + } + int unionIndex54 = (decoder.readIndex()); + if (unionIndex54 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(54, null); + } else { + if (unionIndex54 == 1) { + Utf8 charSequence54; + Object oldString54 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(54); + if (oldString54 instanceof Utf8) { + charSequence54 = (decoder).readString(((Utf8) oldString54)); + } else { + charSequence54 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(54, charSequence54); + } else { + throw new RuntimeException(("Illegal union index for 'F54': "+ unionIndex54)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex55 = (decoder.readIndex()); + if (unionIndex55 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(55, null); + } else { + if (unionIndex55 == 1) { + Utf8 charSequence55; + Object oldString55 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(55); + if (oldString55 instanceof Utf8) { + charSequence55 = (decoder).readString(((Utf8) oldString55)); + } else { + charSequence55 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(55, charSequence55); + } else { + throw new RuntimeException(("Illegal union index for 'F55': "+ unionIndex55)); + } + } + int unionIndex56 = (decoder.readIndex()); + if (unionIndex56 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(56, null); + } else { + if (unionIndex56 == 1) { + Utf8 charSequence56; + Object oldString56 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(56); + if (oldString56 instanceof Utf8) { + charSequence56 = (decoder).readString(((Utf8) oldString56)); + } else { + charSequence56 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(56, charSequence56); + } else { + throw new RuntimeException(("Illegal union index for 'F56': "+ unionIndex56)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex57 = (decoder.readIndex()); + if (unionIndex57 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(57, null); + } else { + if (unionIndex57 == 1) { + Utf8 charSequence57; + Object oldString57 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(57); + if (oldString57 instanceof Utf8) { + charSequence57 = (decoder).readString(((Utf8) oldString57)); + } else { + charSequence57 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(57, charSequence57); + } else { + throw new RuntimeException(("Illegal union index for 'F57': "+ unionIndex57)); + } + } + int unionIndex58 = (decoder.readIndex()); + if (unionIndex58 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(58, null); + } else { + if (unionIndex58 == 1) { + Utf8 charSequence58; + Object oldString58 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(58); + if (oldString58 instanceof Utf8) { + charSequence58 = (decoder).readString(((Utf8) oldString58)); + } else { + charSequence58 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(58, charSequence58); + } else { + throw new RuntimeException(("Illegal union index for 'F58': "+ unionIndex58)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex59 = (decoder.readIndex()); + if (unionIndex59 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(59, null); + } else { + if (unionIndex59 == 1) { + Utf8 charSequence59; + Object oldString59 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(59); + if (oldString59 instanceof Utf8) { + charSequence59 = (decoder).readString(((Utf8) oldString59)); + } else { + charSequence59 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(59, charSequence59); + } else { + throw new RuntimeException(("Illegal union index for 'F59': "+ unionIndex59)); + } + } + int unionIndex60 = (decoder.readIndex()); + if (unionIndex60 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(60, null); + } else { + if (unionIndex60 == 1) { + Utf8 charSequence60; + Object oldString60 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(60); + if (oldString60 instanceof Utf8) { + charSequence60 = (decoder).readString(((Utf8) oldString60)); + } else { + charSequence60 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(60, charSequence60); + } else { + throw new RuntimeException(("Illegal union index for 'F60': "+ unionIndex60)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex61 = (decoder.readIndex()); + if (unionIndex61 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(61, null); + } else { + if (unionIndex61 == 1) { + Utf8 charSequence61; + Object oldString61 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(61); + if (oldString61 instanceof Utf8) { + charSequence61 = (decoder).readString(((Utf8) oldString61)); + } else { + charSequence61 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(61, charSequence61); + } else { + throw new RuntimeException(("Illegal union index for 'F61': "+ unionIndex61)); + } + } + int unionIndex62 = (decoder.readIndex()); + if (unionIndex62 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(62, null); + } else { + if (unionIndex62 == 1) { + Utf8 charSequence62; + Object oldString62 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(62); + if (oldString62 instanceof Utf8) { + charSequence62 = (decoder).readString(((Utf8) oldString62)); + } else { + charSequence62 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(62, charSequence62); + } else { + throw new RuntimeException(("Illegal union index for 'F62': "+ unionIndex62)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex63 = (decoder.readIndex()); + if (unionIndex63 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(63, null); + } else { + if (unionIndex63 == 1) { + Utf8 charSequence63; + Object oldString63 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(63); + if (oldString63 instanceof Utf8) { + charSequence63 = (decoder).readString(((Utf8) oldString63)); + } else { + charSequence63 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(63, charSequence63); + } else { + throw new RuntimeException(("Illegal union index for 'F63': "+ unionIndex63)); + } + } + int unionIndex64 = (decoder.readIndex()); + if (unionIndex64 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(64, null); + } else { + if (unionIndex64 == 1) { + Utf8 charSequence64; + Object oldString64 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(64); + if (oldString64 instanceof Utf8) { + charSequence64 = (decoder).readString(((Utf8) oldString64)); + } else { + charSequence64 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(64, charSequence64); + } else { + throw new RuntimeException(("Illegal union index for 'F64': "+ unionIndex64)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex65 = (decoder.readIndex()); + if (unionIndex65 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(65, null); + } else { + if (unionIndex65 == 1) { + Utf8 charSequence65; + Object oldString65 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(65); + if (oldString65 instanceof Utf8) { + charSequence65 = (decoder).readString(((Utf8) oldString65)); + } else { + charSequence65 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(65, charSequence65); + } else { + throw new RuntimeException(("Illegal union index for 'F65': "+ unionIndex65)); + } + } + int unionIndex66 = (decoder.readIndex()); + if (unionIndex66 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(66, null); + } else { + if (unionIndex66 == 1) { + Utf8 charSequence66; + Object oldString66 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(66); + if (oldString66 instanceof Utf8) { + charSequence66 = (decoder).readString(((Utf8) oldString66)); + } else { + charSequence66 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(66, charSequence66); + } else { + throw new RuntimeException(("Illegal union index for 'F66': "+ unionIndex66)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex67 = (decoder.readIndex()); + if (unionIndex67 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(67, null); + } else { + if (unionIndex67 == 1) { + Utf8 charSequence67; + Object oldString67 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(67); + if (oldString67 instanceof Utf8) { + charSequence67 = (decoder).readString(((Utf8) oldString67)); + } else { + charSequence67 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(67, charSequence67); + } else { + throw new RuntimeException(("Illegal union index for 'F67': "+ unionIndex67)); + } + } + int unionIndex68 = (decoder.readIndex()); + if (unionIndex68 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(68, null); + } else { + if (unionIndex68 == 1) { + Utf8 charSequence68; + Object oldString68 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(68); + if (oldString68 instanceof Utf8) { + charSequence68 = (decoder).readString(((Utf8) oldString68)); + } else { + charSequence68 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(68, charSequence68); + } else { + throw new RuntimeException(("Illegal union index for 'F68': "+ unionIndex68)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex69 = (decoder.readIndex()); + if (unionIndex69 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(69, null); + } else { + if (unionIndex69 == 1) { + Utf8 charSequence69; + Object oldString69 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(69); + if (oldString69 instanceof Utf8) { + charSequence69 = (decoder).readString(((Utf8) oldString69)); + } else { + charSequence69 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(69, charSequence69); + } else { + throw new RuntimeException(("Illegal union index for 'F69': "+ unionIndex69)); + } + } + int unionIndex70 = (decoder.readIndex()); + if (unionIndex70 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(70, null); + } else { + if (unionIndex70 == 1) { + Utf8 charSequence70; + Object oldString70 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(70); + if (oldString70 instanceof Utf8) { + charSequence70 = (decoder).readString(((Utf8) oldString70)); + } else { + charSequence70 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(70, charSequence70); + } else { + throw new RuntimeException(("Illegal union index for 'F70': "+ unionIndex70)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex71 = (decoder.readIndex()); + if (unionIndex71 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(71, null); + } else { + if (unionIndex71 == 1) { + Utf8 charSequence71; + Object oldString71 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(71); + if (oldString71 instanceof Utf8) { + charSequence71 = (decoder).readString(((Utf8) oldString71)); + } else { + charSequence71 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(71, charSequence71); + } else { + throw new RuntimeException(("Illegal union index for 'F71': "+ unionIndex71)); + } + } + int unionIndex72 = (decoder.readIndex()); + if (unionIndex72 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(72, null); + } else { + if (unionIndex72 == 1) { + Utf8 charSequence72; + Object oldString72 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(72); + if (oldString72 instanceof Utf8) { + charSequence72 = (decoder).readString(((Utf8) oldString72)); + } else { + charSequence72 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(72, charSequence72); + } else { + throw new RuntimeException(("Illegal union index for 'F72': "+ unionIndex72)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex73 = (decoder.readIndex()); + if (unionIndex73 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(73, null); + } else { + if (unionIndex73 == 1) { + Utf8 charSequence73; + Object oldString73 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(73); + if (oldString73 instanceof Utf8) { + charSequence73 = (decoder).readString(((Utf8) oldString73)); + } else { + charSequence73 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(73, charSequence73); + } else { + throw new RuntimeException(("Illegal union index for 'F73': "+ unionIndex73)); + } + } + int unionIndex74 = (decoder.readIndex()); + if (unionIndex74 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(74, null); + } else { + if (unionIndex74 == 1) { + Utf8 charSequence74; + Object oldString74 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(74); + if (oldString74 instanceof Utf8) { + charSequence74 = (decoder).readString(((Utf8) oldString74)); + } else { + charSequence74 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(74, charSequence74); + } else { + throw new RuntimeException(("Illegal union index for 'F74': "+ unionIndex74)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex75 = (decoder.readIndex()); + if (unionIndex75 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(75, null); + } else { + if (unionIndex75 == 1) { + Utf8 charSequence75; + Object oldString75 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(75); + if (oldString75 instanceof Utf8) { + charSequence75 = (decoder).readString(((Utf8) oldString75)); + } else { + charSequence75 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(75, charSequence75); + } else { + throw new RuntimeException(("Illegal union index for 'F75': "+ unionIndex75)); + } + } + int unionIndex76 = (decoder.readIndex()); + if (unionIndex76 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(76, null); + } else { + if (unionIndex76 == 1) { + Utf8 charSequence76; + Object oldString76 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(76); + if (oldString76 instanceof Utf8) { + charSequence76 = (decoder).readString(((Utf8) oldString76)); + } else { + charSequence76 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(76, charSequence76); + } else { + throw new RuntimeException(("Illegal union index for 'F76': "+ unionIndex76)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex77 = (decoder.readIndex()); + if (unionIndex77 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(77, null); + } else { + if (unionIndex77 == 1) { + Utf8 charSequence77; + Object oldString77 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(77); + if (oldString77 instanceof Utf8) { + charSequence77 = (decoder).readString(((Utf8) oldString77)); + } else { + charSequence77 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(77, charSequence77); + } else { + throw new RuntimeException(("Illegal union index for 'F77': "+ unionIndex77)); + } + } + int unionIndex78 = (decoder.readIndex()); + if (unionIndex78 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(78, null); + } else { + if (unionIndex78 == 1) { + Utf8 charSequence78; + Object oldString78 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(78); + if (oldString78 instanceof Utf8) { + charSequence78 = (decoder).readString(((Utf8) oldString78)); + } else { + charSequence78 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(78, charSequence78); + } else { + throw new RuntimeException(("Illegal union index for 'F78': "+ unionIndex78)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex79 = (decoder.readIndex()); + if (unionIndex79 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(79, null); + } else { + if (unionIndex79 == 1) { + Utf8 charSequence79; + Object oldString79 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(79); + if (oldString79 instanceof Utf8) { + charSequence79 = (decoder).readString(((Utf8) oldString79)); + } else { + charSequence79 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(79, charSequence79); + } else { + throw new RuntimeException(("Illegal union index for 'F79': "+ unionIndex79)); + } + } + int unionIndex80 = (decoder.readIndex()); + if (unionIndex80 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(80, null); + } else { + if (unionIndex80 == 1) { + Utf8 charSequence80; + Object oldString80 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(80); + if (oldString80 instanceof Utf8) { + charSequence80 = (decoder).readString(((Utf8) oldString80)); + } else { + charSequence80 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(80, charSequence80); + } else { + throw new RuntimeException(("Illegal union index for 'F80': "+ unionIndex80)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex81 = (decoder.readIndex()); + if (unionIndex81 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(81, null); + } else { + if (unionIndex81 == 1) { + Utf8 charSequence81; + Object oldString81 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(81); + if (oldString81 instanceof Utf8) { + charSequence81 = (decoder).readString(((Utf8) oldString81)); + } else { + charSequence81 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(81, charSequence81); + } else { + throw new RuntimeException(("Illegal union index for 'F81': "+ unionIndex81)); + } + } + int unionIndex82 = (decoder.readIndex()); + if (unionIndex82 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(82, null); + } else { + if (unionIndex82 == 1) { + Utf8 charSequence82; + Object oldString82 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(82); + if (oldString82 instanceof Utf8) { + charSequence82 = (decoder).readString(((Utf8) oldString82)); + } else { + charSequence82 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(82, charSequence82); + } else { + throw new RuntimeException(("Illegal union index for 'F82': "+ unionIndex82)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex83 = (decoder.readIndex()); + if (unionIndex83 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(83, null); + } else { + if (unionIndex83 == 1) { + Utf8 charSequence83; + Object oldString83 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(83); + if (oldString83 instanceof Utf8) { + charSequence83 = (decoder).readString(((Utf8) oldString83)); + } else { + charSequence83 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(83, charSequence83); + } else { + throw new RuntimeException(("Illegal union index for 'F83': "+ unionIndex83)); + } + } + int unionIndex84 = (decoder.readIndex()); + if (unionIndex84 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(84, null); + } else { + if (unionIndex84 == 1) { + Utf8 charSequence84; + Object oldString84 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(84); + if (oldString84 instanceof Utf8) { + charSequence84 = (decoder).readString(((Utf8) oldString84)); + } else { + charSequence84 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(84, charSequence84); + } else { + throw new RuntimeException(("Illegal union index for 'F84': "+ unionIndex84)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex85 = (decoder.readIndex()); + if (unionIndex85 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(85, null); + } else { + if (unionIndex85 == 1) { + Utf8 charSequence85; + Object oldString85 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(85); + if (oldString85 instanceof Utf8) { + charSequence85 = (decoder).readString(((Utf8) oldString85)); + } else { + charSequence85 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(85, charSequence85); + } else { + throw new RuntimeException(("Illegal union index for 'F85': "+ unionIndex85)); + } + } + int unionIndex86 = (decoder.readIndex()); + if (unionIndex86 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(86, null); + } else { + if (unionIndex86 == 1) { + Utf8 charSequence86; + Object oldString86 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(86); + if (oldString86 instanceof Utf8) { + charSequence86 = (decoder).readString(((Utf8) oldString86)); + } else { + charSequence86 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(86, charSequence86); + } else { + throw new RuntimeException(("Illegal union index for 'F86': "+ unionIndex86)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex87 = (decoder.readIndex()); + if (unionIndex87 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(87, null); + } else { + if (unionIndex87 == 1) { + Utf8 charSequence87; + Object oldString87 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(87); + if (oldString87 instanceof Utf8) { + charSequence87 = (decoder).readString(((Utf8) oldString87)); + } else { + charSequence87 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(87, charSequence87); + } else { + throw new RuntimeException(("Illegal union index for 'F87': "+ unionIndex87)); + } + } + int unionIndex88 = (decoder.readIndex()); + if (unionIndex88 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(88, null); + } else { + if (unionIndex88 == 1) { + Utf8 charSequence88; + Object oldString88 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(88); + if (oldString88 instanceof Utf8) { + charSequence88 = (decoder).readString(((Utf8) oldString88)); + } else { + charSequence88 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(88, charSequence88); + } else { + throw new RuntimeException(("Illegal union index for 'F88': "+ unionIndex88)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex89 = (decoder.readIndex()); + if (unionIndex89 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(89, null); + } else { + if (unionIndex89 == 1) { + Utf8 charSequence89; + Object oldString89 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(89); + if (oldString89 instanceof Utf8) { + charSequence89 = (decoder).readString(((Utf8) oldString89)); + } else { + charSequence89 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(89, charSequence89); + } else { + throw new RuntimeException(("Illegal union index for 'F89': "+ unionIndex89)); + } + } + int unionIndex90 = (decoder.readIndex()); + if (unionIndex90 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(90, null); + } else { + if (unionIndex90 == 1) { + Utf8 charSequence90; + Object oldString90 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(90); + if (oldString90 instanceof Utf8) { + charSequence90 = (decoder).readString(((Utf8) oldString90)); + } else { + charSequence90 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(90, charSequence90); + } else { + throw new RuntimeException(("Illegal union index for 'F90': "+ unionIndex90)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex91 = (decoder.readIndex()); + if (unionIndex91 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(91, null); + } else { + if (unionIndex91 == 1) { + Utf8 charSequence91; + Object oldString91 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(91); + if (oldString91 instanceof Utf8) { + charSequence91 = (decoder).readString(((Utf8) oldString91)); + } else { + charSequence91 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(91, charSequence91); + } else { + throw new RuntimeException(("Illegal union index for 'F91': "+ unionIndex91)); + } + } + int unionIndex92 = (decoder.readIndex()); + if (unionIndex92 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(92, null); + } else { + if (unionIndex92 == 1) { + Utf8 charSequence92; + Object oldString92 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(92); + if (oldString92 instanceof Utf8) { + charSequence92 = (decoder).readString(((Utf8) oldString92)); + } else { + charSequence92 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(92, charSequence92); + } else { + throw new RuntimeException(("Illegal union index for 'F92': "+ unionIndex92)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex93 = (decoder.readIndex()); + if (unionIndex93 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(93, null); + } else { + if (unionIndex93 == 1) { + Utf8 charSequence93; + Object oldString93 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(93); + if (oldString93 instanceof Utf8) { + charSequence93 = (decoder).readString(((Utf8) oldString93)); + } else { + charSequence93 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(93, charSequence93); + } else { + throw new RuntimeException(("Illegal union index for 'F93': "+ unionIndex93)); + } + } + int unionIndex94 = (decoder.readIndex()); + if (unionIndex94 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(94, null); + } else { + if (unionIndex94 == 1) { + Utf8 charSequence94; + Object oldString94 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(94); + if (oldString94 instanceof Utf8) { + charSequence94 = (decoder).readString(((Utf8) oldString94)); + } else { + charSequence94 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(94, charSequence94); + } else { + throw new RuntimeException(("Illegal union index for 'F94': "+ unionIndex94)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex95 = (decoder.readIndex()); + if (unionIndex95 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(95, null); + } else { + if (unionIndex95 == 1) { + Utf8 charSequence95; + Object oldString95 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(95); + if (oldString95 instanceof Utf8) { + charSequence95 = (decoder).readString(((Utf8) oldString95)); + } else { + charSequence95 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(95, charSequence95); + } else { + throw new RuntimeException(("Illegal union index for 'F95': "+ unionIndex95)); + } + } + int unionIndex96 = (decoder.readIndex()); + if (unionIndex96 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(96, null); + } else { + if (unionIndex96 == 1) { + Utf8 charSequence96; + Object oldString96 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(96); + if (oldString96 instanceof Utf8) { + charSequence96 = (decoder).readString(((Utf8) oldString96)); + } else { + charSequence96 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(96, charSequence96); + } else { + throw new RuntimeException(("Illegal union index for 'F96': "+ unionIndex96)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex97 = (decoder.readIndex()); + if (unionIndex97 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(97, null); + } else { + if (unionIndex97 == 1) { + Utf8 charSequence97; + Object oldString97 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(97); + if (oldString97 instanceof Utf8) { + charSequence97 = (decoder).readString(((Utf8) oldString97)); + } else { + charSequence97 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(97, charSequence97); + } else { + throw new RuntimeException(("Illegal union index for 'F97': "+ unionIndex97)); + } + } + int unionIndex98 = (decoder.readIndex()); + if (unionIndex98 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(98, null); + } else { + if (unionIndex98 == 1) { + Utf8 charSequence98; + Object oldString98 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(98); + if (oldString98 instanceof Utf8) { + charSequence98 = (decoder).readString(((Utf8) oldString98)); + } else { + charSequence98 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(98, charSequence98); + } else { + throw new RuntimeException(("Illegal union index for 'F98': "+ unionIndex98)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex99 = (decoder.readIndex()); + if (unionIndex99 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(99, null); + } else { + if (unionIndex99 == 1) { + Utf8 charSequence99; + Object oldString99 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(99); + if (oldString99 instanceof Utf8) { + charSequence99 = (decoder).readString(((Utf8) oldString99)); + } else { + charSequence99 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(99, charSequence99); + } else { + throw new RuntimeException(("Illegal union index for 'F99': "+ unionIndex99)); + } + } + int unionIndex100 = (decoder.readIndex()); + if (unionIndex100 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(100, null); + } else { + if (unionIndex100 == 1) { + Utf8 charSequence100; + Object oldString100 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(100); + if (oldString100 instanceof Utf8) { + charSequence100 = (decoder).readString(((Utf8) oldString100)); + } else { + charSequence100 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(100, charSequence100); + } else { + throw new RuntimeException(("Illegal union index for 'F100': "+ unionIndex100)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex101 = (decoder.readIndex()); + if (unionIndex101 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(101, null); + } else { + if (unionIndex101 == 1) { + Utf8 charSequence101; + Object oldString101 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(101); + if (oldString101 instanceof Utf8) { + charSequence101 = (decoder).readString(((Utf8) oldString101)); + } else { + charSequence101 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(101, charSequence101); + } else { + throw new RuntimeException(("Illegal union index for 'F101': "+ unionIndex101)); + } + } + int unionIndex102 = (decoder.readIndex()); + if (unionIndex102 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(102, null); + } else { + if (unionIndex102 == 1) { + Utf8 charSequence102; + Object oldString102 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(102); + if (oldString102 instanceof Utf8) { + charSequence102 = (decoder).readString(((Utf8) oldString102)); + } else { + charSequence102 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(102, charSequence102); + } else { + throw new RuntimeException(("Illegal union index for 'F102': "+ unionIndex102)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex103 = (decoder.readIndex()); + if (unionIndex103 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(103, null); + } else { + if (unionIndex103 == 1) { + Utf8 charSequence103; + Object oldString103 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(103); + if (oldString103 instanceof Utf8) { + charSequence103 = (decoder).readString(((Utf8) oldString103)); + } else { + charSequence103 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(103, charSequence103); + } else { + throw new RuntimeException(("Illegal union index for 'F103': "+ unionIndex103)); + } + } + int unionIndex104 = (decoder.readIndex()); + if (unionIndex104 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(104, null); + } else { + if (unionIndex104 == 1) { + Utf8 charSequence104; + Object oldString104 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(104); + if (oldString104 instanceof Utf8) { + charSequence104 = (decoder).readString(((Utf8) oldString104)); + } else { + charSequence104 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(104, charSequence104); + } else { + throw new RuntimeException(("Illegal union index for 'F104': "+ unionIndex104)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex105 = (decoder.readIndex()); + if (unionIndex105 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(105, null); + } else { + if (unionIndex105 == 1) { + Utf8 charSequence105; + Object oldString105 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(105); + if (oldString105 instanceof Utf8) { + charSequence105 = (decoder).readString(((Utf8) oldString105)); + } else { + charSequence105 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(105, charSequence105); + } else { + throw new RuntimeException(("Illegal union index for 'F105': "+ unionIndex105)); + } + } + int unionIndex106 = (decoder.readIndex()); + if (unionIndex106 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(106, null); + } else { + if (unionIndex106 == 1) { + Utf8 charSequence106; + Object oldString106 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(106); + if (oldString106 instanceof Utf8) { + charSequence106 = (decoder).readString(((Utf8) oldString106)); + } else { + charSequence106 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(106, charSequence106); + } else { + throw new RuntimeException(("Illegal union index for 'F106': "+ unionIndex106)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex107 = (decoder.readIndex()); + if (unionIndex107 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(107, null); + } else { + if (unionIndex107 == 1) { + Utf8 charSequence107; + Object oldString107 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(107); + if (oldString107 instanceof Utf8) { + charSequence107 = (decoder).readString(((Utf8) oldString107)); + } else { + charSequence107 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(107, charSequence107); + } else { + throw new RuntimeException(("Illegal union index for 'F107': "+ unionIndex107)); + } + } + int unionIndex108 = (decoder.readIndex()); + if (unionIndex108 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(108, null); + } else { + if (unionIndex108 == 1) { + Utf8 charSequence108; + Object oldString108 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(108); + if (oldString108 instanceof Utf8) { + charSequence108 = (decoder).readString(((Utf8) oldString108)); + } else { + charSequence108 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(108, charSequence108); + } else { + throw new RuntimeException(("Illegal union index for 'F108': "+ unionIndex108)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex109 = (decoder.readIndex()); + if (unionIndex109 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(109, null); + } else { + if (unionIndex109 == 1) { + Utf8 charSequence109; + Object oldString109 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(109); + if (oldString109 instanceof Utf8) { + charSequence109 = (decoder).readString(((Utf8) oldString109)); + } else { + charSequence109 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(109, charSequence109); + } else { + throw new RuntimeException(("Illegal union index for 'F109': "+ unionIndex109)); + } + } + int unionIndex110 = (decoder.readIndex()); + if (unionIndex110 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(110, null); + } else { + if (unionIndex110 == 1) { + Utf8 charSequence110; + Object oldString110 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(110); + if (oldString110 instanceof Utf8) { + charSequence110 = (decoder).readString(((Utf8) oldString110)); + } else { + charSequence110 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(110, charSequence110); + } else { + throw new RuntimeException(("Illegal union index for 'F110': "+ unionIndex110)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex111 = (decoder.readIndex()); + if (unionIndex111 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(111, null); + } else { + if (unionIndex111 == 1) { + Utf8 charSequence111; + Object oldString111 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(111); + if (oldString111 instanceof Utf8) { + charSequence111 = (decoder).readString(((Utf8) oldString111)); + } else { + charSequence111 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(111, charSequence111); + } else { + throw new RuntimeException(("Illegal union index for 'F111': "+ unionIndex111)); + } + } + int unionIndex112 = (decoder.readIndex()); + if (unionIndex112 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(112, null); + } else { + if (unionIndex112 == 1) { + Utf8 charSequence112; + Object oldString112 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(112); + if (oldString112 instanceof Utf8) { + charSequence112 = (decoder).readString(((Utf8) oldString112)); + } else { + charSequence112 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(112, charSequence112); + } else { + throw new RuntimeException(("Illegal union index for 'F112': "+ unionIndex112)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex113 = (decoder.readIndex()); + if (unionIndex113 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(113, null); + } else { + if (unionIndex113 == 1) { + Utf8 charSequence113; + Object oldString113 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(113); + if (oldString113 instanceof Utf8) { + charSequence113 = (decoder).readString(((Utf8) oldString113)); + } else { + charSequence113 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(113, charSequence113); + } else { + throw new RuntimeException(("Illegal union index for 'F113': "+ unionIndex113)); + } + } + int unionIndex114 = (decoder.readIndex()); + if (unionIndex114 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(114, null); + } else { + if (unionIndex114 == 1) { + Utf8 charSequence114; + Object oldString114 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(114); + if (oldString114 instanceof Utf8) { + charSequence114 = (decoder).readString(((Utf8) oldString114)); + } else { + charSequence114 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(114, charSequence114); + } else { + throw new RuntimeException(("Illegal union index for 'F114': "+ unionIndex114)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex115 = (decoder.readIndex()); + if (unionIndex115 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(115, null); + } else { + if (unionIndex115 == 1) { + Utf8 charSequence115; + Object oldString115 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(115); + if (oldString115 instanceof Utf8) { + charSequence115 = (decoder).readString(((Utf8) oldString115)); + } else { + charSequence115 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(115, charSequence115); + } else { + throw new RuntimeException(("Illegal union index for 'F115': "+ unionIndex115)); + } + } + int unionIndex116 = (decoder.readIndex()); + if (unionIndex116 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(116, null); + } else { + if (unionIndex116 == 1) { + Utf8 charSequence116; + Object oldString116 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(116); + if (oldString116 instanceof Utf8) { + charSequence116 = (decoder).readString(((Utf8) oldString116)); + } else { + charSequence116 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(116, charSequence116); + } else { + throw new RuntimeException(("Illegal union index for 'F116': "+ unionIndex116)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex117 = (decoder.readIndex()); + if (unionIndex117 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(117, null); + } else { + if (unionIndex117 == 1) { + Utf8 charSequence117; + Object oldString117 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(117); + if (oldString117 instanceof Utf8) { + charSequence117 = (decoder).readString(((Utf8) oldString117)); + } else { + charSequence117 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(117, charSequence117); + } else { + throw new RuntimeException(("Illegal union index for 'F117': "+ unionIndex117)); + } + } + int unionIndex118 = (decoder.readIndex()); + if (unionIndex118 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(118, null); + } else { + if (unionIndex118 == 1) { + Utf8 charSequence118; + Object oldString118 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(118); + if (oldString118 instanceof Utf8) { + charSequence118 = (decoder).readString(((Utf8) oldString118)); + } else { + charSequence118 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(118, charSequence118); + } else { + throw new RuntimeException(("Illegal union index for 'F118': "+ unionIndex118)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex119 = (decoder.readIndex()); + if (unionIndex119 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(119, null); + } else { + if (unionIndex119 == 1) { + Utf8 charSequence119; + Object oldString119 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(119); + if (oldString119 instanceof Utf8) { + charSequence119 = (decoder).readString(((Utf8) oldString119)); + } else { + charSequence119 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(119, charSequence119); + } else { + throw new RuntimeException(("Illegal union index for 'F119': "+ unionIndex119)); + } + } + int unionIndex120 = (decoder.readIndex()); + if (unionIndex120 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(120, null); + } else { + if (unionIndex120 == 1) { + Utf8 charSequence120; + Object oldString120 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(120); + if (oldString120 instanceof Utf8) { + charSequence120 = (decoder).readString(((Utf8) oldString120)); + } else { + charSequence120 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(120, charSequence120); + } else { + throw new RuntimeException(("Illegal union index for 'F120': "+ unionIndex120)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex121 = (decoder.readIndex()); + if (unionIndex121 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(121, null); + } else { + if (unionIndex121 == 1) { + Utf8 charSequence121; + Object oldString121 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(121); + if (oldString121 instanceof Utf8) { + charSequence121 = (decoder).readString(((Utf8) oldString121)); + } else { + charSequence121 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(121, charSequence121); + } else { + throw new RuntimeException(("Illegal union index for 'F121': "+ unionIndex121)); + } + } + int unionIndex122 = (decoder.readIndex()); + if (unionIndex122 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(122, null); + } else { + if (unionIndex122 == 1) { + Utf8 charSequence122; + Object oldString122 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(122); + if (oldString122 instanceof Utf8) { + charSequence122 = (decoder).readString(((Utf8) oldString122)); + } else { + charSequence122 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(122, charSequence122); + } else { + throw new RuntimeException(("Illegal union index for 'F122': "+ unionIndex122)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex123 = (decoder.readIndex()); + if (unionIndex123 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(123, null); + } else { + if (unionIndex123 == 1) { + Utf8 charSequence123; + Object oldString123 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(123); + if (oldString123 instanceof Utf8) { + charSequence123 = (decoder).readString(((Utf8) oldString123)); + } else { + charSequence123 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(123, charSequence123); + } else { + throw new RuntimeException(("Illegal union index for 'F123': "+ unionIndex123)); + } + } + int unionIndex124 = (decoder.readIndex()); + if (unionIndex124 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(124, null); + } else { + if (unionIndex124 == 1) { + Utf8 charSequence124; + Object oldString124 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(124); + if (oldString124 instanceof Utf8) { + charSequence124 = (decoder).readString(((Utf8) oldString124)); + } else { + charSequence124 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(124, charSequence124); + } else { + throw new RuntimeException(("Illegal union index for 'F124': "+ unionIndex124)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex125 = (decoder.readIndex()); + if (unionIndex125 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(125, null); + } else { + if (unionIndex125 == 1) { + Utf8 charSequence125; + Object oldString125 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(125); + if (oldString125 instanceof Utf8) { + charSequence125 = (decoder).readString(((Utf8) oldString125)); + } else { + charSequence125 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(125, charSequence125); + } else { + throw new RuntimeException(("Illegal union index for 'F125': "+ unionIndex125)); + } + } + int unionIndex126 = (decoder.readIndex()); + if (unionIndex126 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(126, null); + } else { + if (unionIndex126 == 1) { + Utf8 charSequence126; + Object oldString126 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(126); + if (oldString126 instanceof Utf8) { + charSequence126 = (decoder).readString(((Utf8) oldString126)); + } else { + charSequence126 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(126, charSequence126); + } else { + throw new RuntimeException(("Illegal union index for 'F126': "+ unionIndex126)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex127 = (decoder.readIndex()); + if (unionIndex127 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(127, null); + } else { + if (unionIndex127 == 1) { + Utf8 charSequence127; + Object oldString127 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(127); + if (oldString127 instanceof Utf8) { + charSequence127 = (decoder).readString(((Utf8) oldString127)); + } else { + charSequence127 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(127, charSequence127); + } else { + throw new RuntimeException(("Illegal union index for 'F127': "+ unionIndex127)); + } + } + int unionIndex128 = (decoder.readIndex()); + if (unionIndex128 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(128, null); + } else { + if (unionIndex128 == 1) { + Utf8 charSequence128; + Object oldString128 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(128); + if (oldString128 instanceof Utf8) { + charSequence128 = (decoder).readString(((Utf8) oldString128)); + } else { + charSequence128 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(128, charSequence128); + } else { + throw new RuntimeException(("Illegal union index for 'F128': "+ unionIndex128)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex129 = (decoder.readIndex()); + if (unionIndex129 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(129, null); + } else { + if (unionIndex129 == 1) { + Utf8 charSequence129; + Object oldString129 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(129); + if (oldString129 instanceof Utf8) { + charSequence129 = (decoder).readString(((Utf8) oldString129)); + } else { + charSequence129 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(129, charSequence129); + } else { + throw new RuntimeException(("Illegal union index for 'F129': "+ unionIndex129)); + } + } + int unionIndex130 = (decoder.readIndex()); + if (unionIndex130 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(130, null); + } else { + if (unionIndex130 == 1) { + Utf8 charSequence130; + Object oldString130 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(130); + if (oldString130 instanceof Utf8) { + charSequence130 = (decoder).readString(((Utf8) oldString130)); + } else { + charSequence130 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(130, charSequence130); + } else { + throw new RuntimeException(("Illegal union index for 'F130': "+ unionIndex130)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex131 = (decoder.readIndex()); + if (unionIndex131 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(131, null); + } else { + if (unionIndex131 == 1) { + Utf8 charSequence131; + Object oldString131 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(131); + if (oldString131 instanceof Utf8) { + charSequence131 = (decoder).readString(((Utf8) oldString131)); + } else { + charSequence131 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(131, charSequence131); + } else { + throw new RuntimeException(("Illegal union index for 'F131': "+ unionIndex131)); + } + } + int unionIndex132 = (decoder.readIndex()); + if (unionIndex132 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(132, null); + } else { + if (unionIndex132 == 1) { + Utf8 charSequence132; + Object oldString132 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(132); + if (oldString132 instanceof Utf8) { + charSequence132 = (decoder).readString(((Utf8) oldString132)); + } else { + charSequence132 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(132, charSequence132); + } else { + throw new RuntimeException(("Illegal union index for 'F132': "+ unionIndex132)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex133 = (decoder.readIndex()); + if (unionIndex133 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(133, null); + } else { + if (unionIndex133 == 1) { + Utf8 charSequence133; + Object oldString133 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(133); + if (oldString133 instanceof Utf8) { + charSequence133 = (decoder).readString(((Utf8) oldString133)); + } else { + charSequence133 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(133, charSequence133); + } else { + throw new RuntimeException(("Illegal union index for 'F133': "+ unionIndex133)); + } + } + int unionIndex134 = (decoder.readIndex()); + if (unionIndex134 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(134, null); + } else { + if (unionIndex134 == 1) { + Utf8 charSequence134; + Object oldString134 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(134); + if (oldString134 instanceof Utf8) { + charSequence134 = (decoder).readString(((Utf8) oldString134)); + } else { + charSequence134 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(134, charSequence134); + } else { + throw new RuntimeException(("Illegal union index for 'F134': "+ unionIndex134)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex135 = (decoder.readIndex()); + if (unionIndex135 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(135, null); + } else { + if (unionIndex135 == 1) { + Utf8 charSequence135; + Object oldString135 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(135); + if (oldString135 instanceof Utf8) { + charSequence135 = (decoder).readString(((Utf8) oldString135)); + } else { + charSequence135 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(135, charSequence135); + } else { + throw new RuntimeException(("Illegal union index for 'F135': "+ unionIndex135)); + } + } + int unionIndex136 = (decoder.readIndex()); + if (unionIndex136 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(136, null); + } else { + if (unionIndex136 == 1) { + Utf8 charSequence136; + Object oldString136 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(136); + if (oldString136 instanceof Utf8) { + charSequence136 = (decoder).readString(((Utf8) oldString136)); + } else { + charSequence136 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(136, charSequence136); + } else { + throw new RuntimeException(("Illegal union index for 'F136': "+ unionIndex136)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex137 = (decoder.readIndex()); + if (unionIndex137 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(137, null); + } else { + if (unionIndex137 == 1) { + Utf8 charSequence137; + Object oldString137 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(137); + if (oldString137 instanceof Utf8) { + charSequence137 = (decoder).readString(((Utf8) oldString137)); + } else { + charSequence137 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(137, charSequence137); + } else { + throw new RuntimeException(("Illegal union index for 'F137': "+ unionIndex137)); + } + } + int unionIndex138 = (decoder.readIndex()); + if (unionIndex138 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(138, null); + } else { + if (unionIndex138 == 1) { + Utf8 charSequence138; + Object oldString138 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(138); + if (oldString138 instanceof Utf8) { + charSequence138 = (decoder).readString(((Utf8) oldString138)); + } else { + charSequence138 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(138, charSequence138); + } else { + throw new RuntimeException(("Illegal union index for 'F138': "+ unionIndex138)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex139 = (decoder.readIndex()); + if (unionIndex139 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(139, null); + } else { + if (unionIndex139 == 1) { + Utf8 charSequence139; + Object oldString139 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(139); + if (oldString139 instanceof Utf8) { + charSequence139 = (decoder).readString(((Utf8) oldString139)); + } else { + charSequence139 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(139, charSequence139); + } else { + throw new RuntimeException(("Illegal union index for 'F139': "+ unionIndex139)); + } + } + int unionIndex140 = (decoder.readIndex()); + if (unionIndex140 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(140, null); + } else { + if (unionIndex140 == 1) { + Utf8 charSequence140; + Object oldString140 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(140); + if (oldString140 instanceof Utf8) { + charSequence140 = (decoder).readString(((Utf8) oldString140)); + } else { + charSequence140 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(140, charSequence140); + } else { + throw new RuntimeException(("Illegal union index for 'F140': "+ unionIndex140)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex141 = (decoder.readIndex()); + if (unionIndex141 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(141, null); + } else { + if (unionIndex141 == 1) { + Utf8 charSequence141; + Object oldString141 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(141); + if (oldString141 instanceof Utf8) { + charSequence141 = (decoder).readString(((Utf8) oldString141)); + } else { + charSequence141 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(141, charSequence141); + } else { + throw new RuntimeException(("Illegal union index for 'F141': "+ unionIndex141)); + } + } + int unionIndex142 = (decoder.readIndex()); + if (unionIndex142 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(142, null); + } else { + if (unionIndex142 == 1) { + Utf8 charSequence142; + Object oldString142 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(142); + if (oldString142 instanceof Utf8) { + charSequence142 = (decoder).readString(((Utf8) oldString142)); + } else { + charSequence142 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(142, charSequence142); + } else { + throw new RuntimeException(("Illegal union index for 'F142': "+ unionIndex142)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex143 = (decoder.readIndex()); + if (unionIndex143 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(143, null); + } else { + if (unionIndex143 == 1) { + Utf8 charSequence143; + Object oldString143 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(143); + if (oldString143 instanceof Utf8) { + charSequence143 = (decoder).readString(((Utf8) oldString143)); + } else { + charSequence143 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(143, charSequence143); + } else { + throw new RuntimeException(("Illegal union index for 'F143': "+ unionIndex143)); + } + } + int unionIndex144 = (decoder.readIndex()); + if (unionIndex144 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(144, null); + } else { + if (unionIndex144 == 1) { + Utf8 charSequence144; + Object oldString144 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(144); + if (oldString144 instanceof Utf8) { + charSequence144 = (decoder).readString(((Utf8) oldString144)); + } else { + charSequence144 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(144, charSequence144); + } else { + throw new RuntimeException(("Illegal union index for 'F144': "+ unionIndex144)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex145 = (decoder.readIndex()); + if (unionIndex145 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(145, null); + } else { + if (unionIndex145 == 1) { + Utf8 charSequence145; + Object oldString145 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(145); + if (oldString145 instanceof Utf8) { + charSequence145 = (decoder).readString(((Utf8) oldString145)); + } else { + charSequence145 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(145, charSequence145); + } else { + throw new RuntimeException(("Illegal union index for 'F145': "+ unionIndex145)); + } + } + int unionIndex146 = (decoder.readIndex()); + if (unionIndex146 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(146, null); + } else { + if (unionIndex146 == 1) { + Utf8 charSequence146; + Object oldString146 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(146); + if (oldString146 instanceof Utf8) { + charSequence146 = (decoder).readString(((Utf8) oldString146)); + } else { + charSequence146 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(146, charSequence146); + } else { + throw new RuntimeException(("Illegal union index for 'F146': "+ unionIndex146)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex147 = (decoder.readIndex()); + if (unionIndex147 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(147, null); + } else { + if (unionIndex147 == 1) { + Utf8 charSequence147; + Object oldString147 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(147); + if (oldString147 instanceof Utf8) { + charSequence147 = (decoder).readString(((Utf8) oldString147)); + } else { + charSequence147 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(147, charSequence147); + } else { + throw new RuntimeException(("Illegal union index for 'F147': "+ unionIndex147)); + } + } + int unionIndex148 = (decoder.readIndex()); + if (unionIndex148 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(148, null); + } else { + if (unionIndex148 == 1) { + Utf8 charSequence148; + Object oldString148 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(148); + if (oldString148 instanceof Utf8) { + charSequence148 = (decoder).readString(((Utf8) oldString148)); + } else { + charSequence148 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(148, charSequence148); + } else { + throw new RuntimeException(("Illegal union index for 'F148': "+ unionIndex148)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex149 = (decoder.readIndex()); + if (unionIndex149 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(149, null); + } else { + if (unionIndex149 == 1) { + Utf8 charSequence149; + Object oldString149 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(149); + if (oldString149 instanceof Utf8) { + charSequence149 = (decoder).readString(((Utf8) oldString149)); + } else { + charSequence149 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(149, charSequence149); + } else { + throw new RuntimeException(("Illegal union index for 'F149': "+ unionIndex149)); + } + } + int unionIndex150 = (decoder.readIndex()); + if (unionIndex150 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(150, null); + } else { + if (unionIndex150 == 1) { + Utf8 charSequence150; + Object oldString150 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(150); + if (oldString150 instanceof Utf8) { + charSequence150 = (decoder).readString(((Utf8) oldString150)); + } else { + charSequence150 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(150, charSequence150); + } else { + throw new RuntimeException(("Illegal union index for 'F150': "+ unionIndex150)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex151 = (decoder.readIndex()); + if (unionIndex151 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(151, null); + } else { + if (unionIndex151 == 1) { + Utf8 charSequence151; + Object oldString151 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(151); + if (oldString151 instanceof Utf8) { + charSequence151 = (decoder).readString(((Utf8) oldString151)); + } else { + charSequence151 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(151, charSequence151); + } else { + throw new RuntimeException(("Illegal union index for 'F151': "+ unionIndex151)); + } + } + int unionIndex152 = (decoder.readIndex()); + if (unionIndex152 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(152, null); + } else { + if (unionIndex152 == 1) { + Utf8 charSequence152; + Object oldString152 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(152); + if (oldString152 instanceof Utf8) { + charSequence152 = (decoder).readString(((Utf8) oldString152)); + } else { + charSequence152 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(152, charSequence152); + } else { + throw new RuntimeException(("Illegal union index for 'F152': "+ unionIndex152)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex153 = (decoder.readIndex()); + if (unionIndex153 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(153, null); + } else { + if (unionIndex153 == 1) { + Utf8 charSequence153; + Object oldString153 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(153); + if (oldString153 instanceof Utf8) { + charSequence153 = (decoder).readString(((Utf8) oldString153)); + } else { + charSequence153 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(153, charSequence153); + } else { + throw new RuntimeException(("Illegal union index for 'F153': "+ unionIndex153)); + } + } + int unionIndex154 = (decoder.readIndex()); + if (unionIndex154 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(154, null); + } else { + if (unionIndex154 == 1) { + Utf8 charSequence154; + Object oldString154 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(154); + if (oldString154 instanceof Utf8) { + charSequence154 = (decoder).readString(((Utf8) oldString154)); + } else { + charSequence154 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(154, charSequence154); + } else { + throw new RuntimeException(("Illegal union index for 'F154': "+ unionIndex154)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex155 = (decoder.readIndex()); + if (unionIndex155 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(155, null); + } else { + if (unionIndex155 == 1) { + Utf8 charSequence155; + Object oldString155 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(155); + if (oldString155 instanceof Utf8) { + charSequence155 = (decoder).readString(((Utf8) oldString155)); + } else { + charSequence155 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(155, charSequence155); + } else { + throw new RuntimeException(("Illegal union index for 'F155': "+ unionIndex155)); + } + } + int unionIndex156 = (decoder.readIndex()); + if (unionIndex156 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(156, null); + } else { + if (unionIndex156 == 1) { + Utf8 charSequence156; + Object oldString156 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(156); + if (oldString156 instanceof Utf8) { + charSequence156 = (decoder).readString(((Utf8) oldString156)); + } else { + charSequence156 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(156, charSequence156); + } else { + throw new RuntimeException(("Illegal union index for 'F156': "+ unionIndex156)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex157 = (decoder.readIndex()); + if (unionIndex157 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(157, null); + } else { + if (unionIndex157 == 1) { + Utf8 charSequence157; + Object oldString157 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(157); + if (oldString157 instanceof Utf8) { + charSequence157 = (decoder).readString(((Utf8) oldString157)); + } else { + charSequence157 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(157, charSequence157); + } else { + throw new RuntimeException(("Illegal union index for 'F157': "+ unionIndex157)); + } + } + int unionIndex158 = (decoder.readIndex()); + if (unionIndex158 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(158, null); + } else { + if (unionIndex158 == 1) { + Utf8 charSequence158; + Object oldString158 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(158); + if (oldString158 instanceof Utf8) { + charSequence158 = (decoder).readString(((Utf8) oldString158)); + } else { + charSequence158 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(158, charSequence158); + } else { + throw new RuntimeException(("Illegal union index for 'F158': "+ unionIndex158)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex159 = (decoder.readIndex()); + if (unionIndex159 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(159, null); + } else { + if (unionIndex159 == 1) { + Utf8 charSequence159; + Object oldString159 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(159); + if (oldString159 instanceof Utf8) { + charSequence159 = (decoder).readString(((Utf8) oldString159)); + } else { + charSequence159 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(159, charSequence159); + } else { + throw new RuntimeException(("Illegal union index for 'F159': "+ unionIndex159)); + } + } + int unionIndex160 = (decoder.readIndex()); + if (unionIndex160 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(160, null); + } else { + if (unionIndex160 == 1) { + Utf8 charSequence160; + Object oldString160 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(160); + if (oldString160 instanceof Utf8) { + charSequence160 = (decoder).readString(((Utf8) oldString160)); + } else { + charSequence160 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(160, charSequence160); + } else { + throw new RuntimeException(("Illegal union index for 'F160': "+ unionIndex160)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex161 = (decoder.readIndex()); + if (unionIndex161 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(161, null); + } else { + if (unionIndex161 == 1) { + Utf8 charSequence161; + Object oldString161 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(161); + if (oldString161 instanceof Utf8) { + charSequence161 = (decoder).readString(((Utf8) oldString161)); + } else { + charSequence161 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(161, charSequence161); + } else { + throw new RuntimeException(("Illegal union index for 'F161': "+ unionIndex161)); + } + } + int unionIndex162 = (decoder.readIndex()); + if (unionIndex162 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(162, null); + } else { + if (unionIndex162 == 1) { + Utf8 charSequence162; + Object oldString162 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(162); + if (oldString162 instanceof Utf8) { + charSequence162 = (decoder).readString(((Utf8) oldString162)); + } else { + charSequence162 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(162, charSequence162); + } else { + throw new RuntimeException(("Illegal union index for 'F162': "+ unionIndex162)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex163 = (decoder.readIndex()); + if (unionIndex163 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(163, null); + } else { + if (unionIndex163 == 1) { + Utf8 charSequence163; + Object oldString163 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(163); + if (oldString163 instanceof Utf8) { + charSequence163 = (decoder).readString(((Utf8) oldString163)); + } else { + charSequence163 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(163, charSequence163); + } else { + throw new RuntimeException(("Illegal union index for 'F163': "+ unionIndex163)); + } + } + int unionIndex164 = (decoder.readIndex()); + if (unionIndex164 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(164, null); + } else { + if (unionIndex164 == 1) { + Utf8 charSequence164; + Object oldString164 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(164); + if (oldString164 instanceof Utf8) { + charSequence164 = (decoder).readString(((Utf8) oldString164)); + } else { + charSequence164 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(164, charSequence164); + } else { + throw new RuntimeException(("Illegal union index for 'F164': "+ unionIndex164)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex165 = (decoder.readIndex()); + if (unionIndex165 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(165, null); + } else { + if (unionIndex165 == 1) { + Utf8 charSequence165; + Object oldString165 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(165); + if (oldString165 instanceof Utf8) { + charSequence165 = (decoder).readString(((Utf8) oldString165)); + } else { + charSequence165 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(165, charSequence165); + } else { + throw new RuntimeException(("Illegal union index for 'F165': "+ unionIndex165)); + } + } + int unionIndex166 = (decoder.readIndex()); + if (unionIndex166 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(166, null); + } else { + if (unionIndex166 == 1) { + Utf8 charSequence166; + Object oldString166 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(166); + if (oldString166 instanceof Utf8) { + charSequence166 = (decoder).readString(((Utf8) oldString166)); + } else { + charSequence166 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(166, charSequence166); + } else { + throw new RuntimeException(("Illegal union index for 'F166': "+ unionIndex166)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex167 = (decoder.readIndex()); + if (unionIndex167 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(167, null); + } else { + if (unionIndex167 == 1) { + Utf8 charSequence167; + Object oldString167 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(167); + if (oldString167 instanceof Utf8) { + charSequence167 = (decoder).readString(((Utf8) oldString167)); + } else { + charSequence167 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(167, charSequence167); + } else { + throw new RuntimeException(("Illegal union index for 'F167': "+ unionIndex167)); + } + } + int unionIndex168 = (decoder.readIndex()); + if (unionIndex168 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(168, null); + } else { + if (unionIndex168 == 1) { + Utf8 charSequence168; + Object oldString168 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(168); + if (oldString168 instanceof Utf8) { + charSequence168 = (decoder).readString(((Utf8) oldString168)); + } else { + charSequence168 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(168, charSequence168); + } else { + throw new RuntimeException(("Illegal union index for 'F168': "+ unionIndex168)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex169 = (decoder.readIndex()); + if (unionIndex169 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(169, null); + } else { + if (unionIndex169 == 1) { + Utf8 charSequence169; + Object oldString169 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(169); + if (oldString169 instanceof Utf8) { + charSequence169 = (decoder).readString(((Utf8) oldString169)); + } else { + charSequence169 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(169, charSequence169); + } else { + throw new RuntimeException(("Illegal union index for 'F169': "+ unionIndex169)); + } + } + int unionIndex170 = (decoder.readIndex()); + if (unionIndex170 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(170, null); + } else { + if (unionIndex170 == 1) { + Utf8 charSequence170; + Object oldString170 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(170); + if (oldString170 instanceof Utf8) { + charSequence170 = (decoder).readString(((Utf8) oldString170)); + } else { + charSequence170 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(170, charSequence170); + } else { + throw new RuntimeException(("Illegal union index for 'F170': "+ unionIndex170)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex171 = (decoder.readIndex()); + if (unionIndex171 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(171, null); + } else { + if (unionIndex171 == 1) { + Utf8 charSequence171; + Object oldString171 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(171); + if (oldString171 instanceof Utf8) { + charSequence171 = (decoder).readString(((Utf8) oldString171)); + } else { + charSequence171 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(171, charSequence171); + } else { + throw new RuntimeException(("Illegal union index for 'F171': "+ unionIndex171)); + } + } + int unionIndex172 = (decoder.readIndex()); + if (unionIndex172 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(172, null); + } else { + if (unionIndex172 == 1) { + Utf8 charSequence172; + Object oldString172 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(172); + if (oldString172 instanceof Utf8) { + charSequence172 = (decoder).readString(((Utf8) oldString172)); + } else { + charSequence172 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(172, charSequence172); + } else { + throw new RuntimeException(("Illegal union index for 'F172': "+ unionIndex172)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex173 = (decoder.readIndex()); + if (unionIndex173 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(173, null); + } else { + if (unionIndex173 == 1) { + Utf8 charSequence173; + Object oldString173 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(173); + if (oldString173 instanceof Utf8) { + charSequence173 = (decoder).readString(((Utf8) oldString173)); + } else { + charSequence173 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(173, charSequence173); + } else { + throw new RuntimeException(("Illegal union index for 'F173': "+ unionIndex173)); + } + } + int unionIndex174 = (decoder.readIndex()); + if (unionIndex174 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(174, null); + } else { + if (unionIndex174 == 1) { + Utf8 charSequence174; + Object oldString174 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(174); + if (oldString174 instanceof Utf8) { + charSequence174 = (decoder).readString(((Utf8) oldString174)); + } else { + charSequence174 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(174, charSequence174); + } else { + throw new RuntimeException(("Illegal union index for 'F174': "+ unionIndex174)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex175 = (decoder.readIndex()); + if (unionIndex175 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(175, null); + } else { + if (unionIndex175 == 1) { + Utf8 charSequence175; + Object oldString175 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(175); + if (oldString175 instanceof Utf8) { + charSequence175 = (decoder).readString(((Utf8) oldString175)); + } else { + charSequence175 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(175, charSequence175); + } else { + throw new RuntimeException(("Illegal union index for 'F175': "+ unionIndex175)); + } + } + int unionIndex176 = (decoder.readIndex()); + if (unionIndex176 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(176, null); + } else { + if (unionIndex176 == 1) { + Utf8 charSequence176; + Object oldString176 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(176); + if (oldString176 instanceof Utf8) { + charSequence176 = (decoder).readString(((Utf8) oldString176)); + } else { + charSequence176 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(176, charSequence176); + } else { + throw new RuntimeException(("Illegal union index for 'F176': "+ unionIndex176)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex177 = (decoder.readIndex()); + if (unionIndex177 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(177, null); + } else { + if (unionIndex177 == 1) { + Utf8 charSequence177; + Object oldString177 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(177); + if (oldString177 instanceof Utf8) { + charSequence177 = (decoder).readString(((Utf8) oldString177)); + } else { + charSequence177 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(177, charSequence177); + } else { + throw new RuntimeException(("Illegal union index for 'F177': "+ unionIndex177)); + } + } + int unionIndex178 = (decoder.readIndex()); + if (unionIndex178 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(178, null); + } else { + if (unionIndex178 == 1) { + Utf8 charSequence178; + Object oldString178 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(178); + if (oldString178 instanceof Utf8) { + charSequence178 = (decoder).readString(((Utf8) oldString178)); + } else { + charSequence178 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(178, charSequence178); + } else { + throw new RuntimeException(("Illegal union index for 'F178': "+ unionIndex178)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex179 = (decoder.readIndex()); + if (unionIndex179 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(179, null); + } else { + if (unionIndex179 == 1) { + Utf8 charSequence179; + Object oldString179 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(179); + if (oldString179 instanceof Utf8) { + charSequence179 = (decoder).readString(((Utf8) oldString179)); + } else { + charSequence179 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(179, charSequence179); + } else { + throw new RuntimeException(("Illegal union index for 'F179': "+ unionIndex179)); + } + } + int unionIndex180 = (decoder.readIndex()); + if (unionIndex180 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(180, null); + } else { + if (unionIndex180 == 1) { + Utf8 charSequence180; + Object oldString180 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(180); + if (oldString180 instanceof Utf8) { + charSequence180 = (decoder).readString(((Utf8) oldString180)); + } else { + charSequence180 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(180, charSequence180); + } else { + throw new RuntimeException(("Illegal union index for 'F180': "+ unionIndex180)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex181 = (decoder.readIndex()); + if (unionIndex181 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(181, null); + } else { + if (unionIndex181 == 1) { + Utf8 charSequence181; + Object oldString181 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(181); + if (oldString181 instanceof Utf8) { + charSequence181 = (decoder).readString(((Utf8) oldString181)); + } else { + charSequence181 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(181, charSequence181); + } else { + throw new RuntimeException(("Illegal union index for 'F181': "+ unionIndex181)); + } + } + int unionIndex182 = (decoder.readIndex()); + if (unionIndex182 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(182, null); + } else { + if (unionIndex182 == 1) { + Utf8 charSequence182; + Object oldString182 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(182); + if (oldString182 instanceof Utf8) { + charSequence182 = (decoder).readString(((Utf8) oldString182)); + } else { + charSequence182 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(182, charSequence182); + } else { + throw new RuntimeException(("Illegal union index for 'F182': "+ unionIndex182)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex183 = (decoder.readIndex()); + if (unionIndex183 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(183, null); + } else { + if (unionIndex183 == 1) { + Utf8 charSequence183; + Object oldString183 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(183); + if (oldString183 instanceof Utf8) { + charSequence183 = (decoder).readString(((Utf8) oldString183)); + } else { + charSequence183 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(183, charSequence183); + } else { + throw new RuntimeException(("Illegal union index for 'F183': "+ unionIndex183)); + } + } + int unionIndex184 = (decoder.readIndex()); + if (unionIndex184 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(184, null); + } else { + if (unionIndex184 == 1) { + Utf8 charSequence184; + Object oldString184 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(184); + if (oldString184 instanceof Utf8) { + charSequence184 = (decoder).readString(((Utf8) oldString184)); + } else { + charSequence184 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(184, charSequence184); + } else { + throw new RuntimeException(("Illegal union index for 'F184': "+ unionIndex184)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex185 = (decoder.readIndex()); + if (unionIndex185 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(185, null); + } else { + if (unionIndex185 == 1) { + Utf8 charSequence185; + Object oldString185 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(185); + if (oldString185 instanceof Utf8) { + charSequence185 = (decoder).readString(((Utf8) oldString185)); + } else { + charSequence185 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(185, charSequence185); + } else { + throw new RuntimeException(("Illegal union index for 'F185': "+ unionIndex185)); + } + } + int unionIndex186 = (decoder.readIndex()); + if (unionIndex186 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(186, null); + } else { + if (unionIndex186 == 1) { + Utf8 charSequence186; + Object oldString186 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(186); + if (oldString186 instanceof Utf8) { + charSequence186 = (decoder).readString(((Utf8) oldString186)); + } else { + charSequence186 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(186, charSequence186); + } else { + throw new RuntimeException(("Illegal union index for 'F186': "+ unionIndex186)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex187 = (decoder.readIndex()); + if (unionIndex187 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(187, null); + } else { + if (unionIndex187 == 1) { + Utf8 charSequence187; + Object oldString187 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(187); + if (oldString187 instanceof Utf8) { + charSequence187 = (decoder).readString(((Utf8) oldString187)); + } else { + charSequence187 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(187, charSequence187); + } else { + throw new RuntimeException(("Illegal union index for 'F187': "+ unionIndex187)); + } + } + int unionIndex188 = (decoder.readIndex()); + if (unionIndex188 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(188, null); + } else { + if (unionIndex188 == 1) { + Utf8 charSequence188; + Object oldString188 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(188); + if (oldString188 instanceof Utf8) { + charSequence188 = (decoder).readString(((Utf8) oldString188)); + } else { + charSequence188 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(188, charSequence188); + } else { + throw new RuntimeException(("Illegal union index for 'F188': "+ unionIndex188)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex189 = (decoder.readIndex()); + if (unionIndex189 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(189, null); + } else { + if (unionIndex189 == 1) { + Utf8 charSequence189; + Object oldString189 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(189); + if (oldString189 instanceof Utf8) { + charSequence189 = (decoder).readString(((Utf8) oldString189)); + } else { + charSequence189 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(189, charSequence189); + } else { + throw new RuntimeException(("Illegal union index for 'F189': "+ unionIndex189)); + } + } + int unionIndex190 = (decoder.readIndex()); + if (unionIndex190 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(190, null); + } else { + if (unionIndex190 == 1) { + Utf8 charSequence190; + Object oldString190 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(190); + if (oldString190 instanceof Utf8) { + charSequence190 = (decoder).readString(((Utf8) oldString190)); + } else { + charSequence190 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(190, charSequence190); + } else { + throw new RuntimeException(("Illegal union index for 'F190': "+ unionIndex190)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex191 = (decoder.readIndex()); + if (unionIndex191 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(191, null); + } else { + if (unionIndex191 == 1) { + Utf8 charSequence191; + Object oldString191 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(191); + if (oldString191 instanceof Utf8) { + charSequence191 = (decoder).readString(((Utf8) oldString191)); + } else { + charSequence191 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(191, charSequence191); + } else { + throw new RuntimeException(("Illegal union index for 'F191': "+ unionIndex191)); + } + } + int unionIndex192 = (decoder.readIndex()); + if (unionIndex192 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(192, null); + } else { + if (unionIndex192 == 1) { + Utf8 charSequence192; + Object oldString192 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(192); + if (oldString192 instanceof Utf8) { + charSequence192 = (decoder).readString(((Utf8) oldString192)); + } else { + charSequence192 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(192, charSequence192); + } else { + throw new RuntimeException(("Illegal union index for 'F192': "+ unionIndex192)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex193 = (decoder.readIndex()); + if (unionIndex193 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(193, null); + } else { + if (unionIndex193 == 1) { + Utf8 charSequence193; + Object oldString193 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(193); + if (oldString193 instanceof Utf8) { + charSequence193 = (decoder).readString(((Utf8) oldString193)); + } else { + charSequence193 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(193, charSequence193); + } else { + throw new RuntimeException(("Illegal union index for 'F193': "+ unionIndex193)); + } + } + int unionIndex194 = (decoder.readIndex()); + if (unionIndex194 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(194, null); + } else { + if (unionIndex194 == 1) { + Utf8 charSequence194; + Object oldString194 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(194); + if (oldString194 instanceof Utf8) { + charSequence194 = (decoder).readString(((Utf8) oldString194)); + } else { + charSequence194 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(194, charSequence194); + } else { + throw new RuntimeException(("Illegal union index for 'F194': "+ unionIndex194)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex195 = (decoder.readIndex()); + if (unionIndex195 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(195, null); + } else { + if (unionIndex195 == 1) { + Utf8 charSequence195; + Object oldString195 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(195); + if (oldString195 instanceof Utf8) { + charSequence195 = (decoder).readString(((Utf8) oldString195)); + } else { + charSequence195 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(195, charSequence195); + } else { + throw new RuntimeException(("Illegal union index for 'F195': "+ unionIndex195)); + } + } + int unionIndex196 = (decoder.readIndex()); + if (unionIndex196 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(196, null); + } else { + if (unionIndex196 == 1) { + Utf8 charSequence196; + Object oldString196 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(196); + if (oldString196 instanceof Utf8) { + charSequence196 = (decoder).readString(((Utf8) oldString196)); + } else { + charSequence196 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(196, charSequence196); + } else { + throw new RuntimeException(("Illegal union index for 'F196': "+ unionIndex196)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex197 = (decoder.readIndex()); + if (unionIndex197 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(197, null); + } else { + if (unionIndex197 == 1) { + Utf8 charSequence197; + Object oldString197 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(197); + if (oldString197 instanceof Utf8) { + charSequence197 = (decoder).readString(((Utf8) oldString197)); + } else { + charSequence197 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(197, charSequence197); + } else { + throw new RuntimeException(("Illegal union index for 'F197': "+ unionIndex197)); + } + } + int unionIndex198 = (decoder.readIndex()); + if (unionIndex198 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(198, null); + } else { + if (unionIndex198 == 1) { + Utf8 charSequence198; + Object oldString198 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(198); + if (oldString198 instanceof Utf8) { + charSequence198 = (decoder).readString(((Utf8) oldString198)); + } else { + charSequence198 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(198, charSequence198); + } else { + throw new RuntimeException(("Illegal union index for 'F198': "+ unionIndex198)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex199 = (decoder.readIndex()); + if (unionIndex199 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(199, null); + } else { + if (unionIndex199 == 1) { + Utf8 charSequence199; + Object oldString199 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(199); + if (oldString199 instanceof Utf8) { + charSequence199 = (decoder).readString(((Utf8) oldString199)); + } else { + charSequence199 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(199, charSequence199); + } else { + throw new RuntimeException(("Illegal union index for 'F199': "+ unionIndex199)); + } + } + int unionIndex200 = (decoder.readIndex()); + if (unionIndex200 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(200, null); + } else { + if (unionIndex200 == 1) { + Utf8 charSequence200; + Object oldString200 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(200); + if (oldString200 instanceof Utf8) { + charSequence200 = (decoder).readString(((Utf8) oldString200)); + } else { + charSequence200 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(200, charSequence200); + } else { + throw new RuntimeException(("Illegal union index for 'F200': "+ unionIndex200)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex201 = (decoder.readIndex()); + if (unionIndex201 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(201, null); + } else { + if (unionIndex201 == 1) { + Utf8 charSequence201; + Object oldString201 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(201); + if (oldString201 instanceof Utf8) { + charSequence201 = (decoder).readString(((Utf8) oldString201)); + } else { + charSequence201 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(201, charSequence201); + } else { + throw new RuntimeException(("Illegal union index for 'F201': "+ unionIndex201)); + } + } + int unionIndex202 = (decoder.readIndex()); + if (unionIndex202 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(202, null); + } else { + if (unionIndex202 == 1) { + Utf8 charSequence202; + Object oldString202 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(202); + if (oldString202 instanceof Utf8) { + charSequence202 = (decoder).readString(((Utf8) oldString202)); + } else { + charSequence202 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(202, charSequence202); + } else { + throw new RuntimeException(("Illegal union index for 'F202': "+ unionIndex202)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex203 = (decoder.readIndex()); + if (unionIndex203 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(203, null); + } else { + if (unionIndex203 == 1) { + Utf8 charSequence203; + Object oldString203 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(203); + if (oldString203 instanceof Utf8) { + charSequence203 = (decoder).readString(((Utf8) oldString203)); + } else { + charSequence203 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(203, charSequence203); + } else { + throw new RuntimeException(("Illegal union index for 'F203': "+ unionIndex203)); + } + } + int unionIndex204 = (decoder.readIndex()); + if (unionIndex204 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(204, null); + } else { + if (unionIndex204 == 1) { + Utf8 charSequence204; + Object oldString204 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(204); + if (oldString204 instanceof Utf8) { + charSequence204 = (decoder).readString(((Utf8) oldString204)); + } else { + charSequence204 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(204, charSequence204); + } else { + throw new RuntimeException(("Illegal union index for 'F204': "+ unionIndex204)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex205 = (decoder.readIndex()); + if (unionIndex205 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(205, null); + } else { + if (unionIndex205 == 1) { + Utf8 charSequence205; + Object oldString205 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(205); + if (oldString205 instanceof Utf8) { + charSequence205 = (decoder).readString(((Utf8) oldString205)); + } else { + charSequence205 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(205, charSequence205); + } else { + throw new RuntimeException(("Illegal union index for 'F205': "+ unionIndex205)); + } + } + int unionIndex206 = (decoder.readIndex()); + if (unionIndex206 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(206, null); + } else { + if (unionIndex206 == 1) { + Utf8 charSequence206; + Object oldString206 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(206); + if (oldString206 instanceof Utf8) { + charSequence206 = (decoder).readString(((Utf8) oldString206)); + } else { + charSequence206 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(206, charSequence206); + } else { + throw new RuntimeException(("Illegal union index for 'F206': "+ unionIndex206)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex207 = (decoder.readIndex()); + if (unionIndex207 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(207, null); + } else { + if (unionIndex207 == 1) { + Utf8 charSequence207; + Object oldString207 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(207); + if (oldString207 instanceof Utf8) { + charSequence207 = (decoder).readString(((Utf8) oldString207)); + } else { + charSequence207 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(207, charSequence207); + } else { + throw new RuntimeException(("Illegal union index for 'F207': "+ unionIndex207)); + } + } + int unionIndex208 = (decoder.readIndex()); + if (unionIndex208 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(208, null); + } else { + if (unionIndex208 == 1) { + Utf8 charSequence208; + Object oldString208 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(208); + if (oldString208 instanceof Utf8) { + charSequence208 = (decoder).readString(((Utf8) oldString208)); + } else { + charSequence208 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(208, charSequence208); + } else { + throw new RuntimeException(("Illegal union index for 'F208': "+ unionIndex208)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex209 = (decoder.readIndex()); + if (unionIndex209 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(209, null); + } else { + if (unionIndex209 == 1) { + Utf8 charSequence209; + Object oldString209 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(209); + if (oldString209 instanceof Utf8) { + charSequence209 = (decoder).readString(((Utf8) oldString209)); + } else { + charSequence209 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(209, charSequence209); + } else { + throw new RuntimeException(("Illegal union index for 'F209': "+ unionIndex209)); + } + } + int unionIndex210 = (decoder.readIndex()); + if (unionIndex210 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(210, null); + } else { + if (unionIndex210 == 1) { + Utf8 charSequence210; + Object oldString210 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(210); + if (oldString210 instanceof Utf8) { + charSequence210 = (decoder).readString(((Utf8) oldString210)); + } else { + charSequence210 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(210, charSequence210); + } else { + throw new RuntimeException(("Illegal union index for 'F210': "+ unionIndex210)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex211 = (decoder.readIndex()); + if (unionIndex211 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(211, null); + } else { + if (unionIndex211 == 1) { + Utf8 charSequence211; + Object oldString211 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(211); + if (oldString211 instanceof Utf8) { + charSequence211 = (decoder).readString(((Utf8) oldString211)); + } else { + charSequence211 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(211, charSequence211); + } else { + throw new RuntimeException(("Illegal union index for 'F211': "+ unionIndex211)); + } + } + int unionIndex212 = (decoder.readIndex()); + if (unionIndex212 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(212, null); + } else { + if (unionIndex212 == 1) { + Utf8 charSequence212; + Object oldString212 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(212); + if (oldString212 instanceof Utf8) { + charSequence212 = (decoder).readString(((Utf8) oldString212)); + } else { + charSequence212 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(212, charSequence212); + } else { + throw new RuntimeException(("Illegal union index for 'F212': "+ unionIndex212)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex213 = (decoder.readIndex()); + if (unionIndex213 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(213, null); + } else { + if (unionIndex213 == 1) { + Utf8 charSequence213; + Object oldString213 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(213); + if (oldString213 instanceof Utf8) { + charSequence213 = (decoder).readString(((Utf8) oldString213)); + } else { + charSequence213 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(213, charSequence213); + } else { + throw new RuntimeException(("Illegal union index for 'F213': "+ unionIndex213)); + } + } + int unionIndex214 = (decoder.readIndex()); + if (unionIndex214 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(214, null); + } else { + if (unionIndex214 == 1) { + Utf8 charSequence214; + Object oldString214 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(214); + if (oldString214 instanceof Utf8) { + charSequence214 = (decoder).readString(((Utf8) oldString214)); + } else { + charSequence214 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(214, charSequence214); + } else { + throw new RuntimeException(("Illegal union index for 'F214': "+ unionIndex214)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex215 = (decoder.readIndex()); + if (unionIndex215 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(215, null); + } else { + if (unionIndex215 == 1) { + Utf8 charSequence215; + Object oldString215 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(215); + if (oldString215 instanceof Utf8) { + charSequence215 = (decoder).readString(((Utf8) oldString215)); + } else { + charSequence215 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(215, charSequence215); + } else { + throw new RuntimeException(("Illegal union index for 'F215': "+ unionIndex215)); + } + } + int unionIndex216 = (decoder.readIndex()); + if (unionIndex216 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(216, null); + } else { + if (unionIndex216 == 1) { + Utf8 charSequence216; + Object oldString216 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(216); + if (oldString216 instanceof Utf8) { + charSequence216 = (decoder).readString(((Utf8) oldString216)); + } else { + charSequence216 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(216, charSequence216); + } else { + throw new RuntimeException(("Illegal union index for 'F216': "+ unionIndex216)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex217 = (decoder.readIndex()); + if (unionIndex217 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(217, null); + } else { + if (unionIndex217 == 1) { + Utf8 charSequence217; + Object oldString217 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(217); + if (oldString217 instanceof Utf8) { + charSequence217 = (decoder).readString(((Utf8) oldString217)); + } else { + charSequence217 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(217, charSequence217); + } else { + throw new RuntimeException(("Illegal union index for 'F217': "+ unionIndex217)); + } + } + int unionIndex218 = (decoder.readIndex()); + if (unionIndex218 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(218, null); + } else { + if (unionIndex218 == 1) { + Utf8 charSequence218; + Object oldString218 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(218); + if (oldString218 instanceof Utf8) { + charSequence218 = (decoder).readString(((Utf8) oldString218)); + } else { + charSequence218 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(218, charSequence218); + } else { + throw new RuntimeException(("Illegal union index for 'F218': "+ unionIndex218)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex219 = (decoder.readIndex()); + if (unionIndex219 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(219, null); + } else { + if (unionIndex219 == 1) { + Utf8 charSequence219; + Object oldString219 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(219); + if (oldString219 instanceof Utf8) { + charSequence219 = (decoder).readString(((Utf8) oldString219)); + } else { + charSequence219 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(219, charSequence219); + } else { + throw new RuntimeException(("Illegal union index for 'F219': "+ unionIndex219)); + } + } + int unionIndex220 = (decoder.readIndex()); + if (unionIndex220 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(220, null); + } else { + if (unionIndex220 == 1) { + Utf8 charSequence220; + Object oldString220 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(220); + if (oldString220 instanceof Utf8) { + charSequence220 = (decoder).readString(((Utf8) oldString220)); + } else { + charSequence220 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(220, charSequence220); + } else { + throw new RuntimeException(("Illegal union index for 'F220': "+ unionIndex220)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex221 = (decoder.readIndex()); + if (unionIndex221 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(221, null); + } else { + if (unionIndex221 == 1) { + Utf8 charSequence221; + Object oldString221 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(221); + if (oldString221 instanceof Utf8) { + charSequence221 = (decoder).readString(((Utf8) oldString221)); + } else { + charSequence221 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(221, charSequence221); + } else { + throw new RuntimeException(("Illegal union index for 'F221': "+ unionIndex221)); + } + } + int unionIndex222 = (decoder.readIndex()); + if (unionIndex222 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(222, null); + } else { + if (unionIndex222 == 1) { + Utf8 charSequence222; + Object oldString222 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(222); + if (oldString222 instanceof Utf8) { + charSequence222 = (decoder).readString(((Utf8) oldString222)); + } else { + charSequence222 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(222, charSequence222); + } else { + throw new RuntimeException(("Illegal union index for 'F222': "+ unionIndex222)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex223 = (decoder.readIndex()); + if (unionIndex223 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(223, null); + } else { + if (unionIndex223 == 1) { + Utf8 charSequence223; + Object oldString223 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(223); + if (oldString223 instanceof Utf8) { + charSequence223 = (decoder).readString(((Utf8) oldString223)); + } else { + charSequence223 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(223, charSequence223); + } else { + throw new RuntimeException(("Illegal union index for 'F223': "+ unionIndex223)); + } + } + int unionIndex224 = (decoder.readIndex()); + if (unionIndex224 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(224, null); + } else { + if (unionIndex224 == 1) { + Utf8 charSequence224; + Object oldString224 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(224); + if (oldString224 instanceof Utf8) { + charSequence224 = (decoder).readString(((Utf8) oldString224)); + } else { + charSequence224 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(224, charSequence224); + } else { + throw new RuntimeException(("Illegal union index for 'F224': "+ unionIndex224)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex225 = (decoder.readIndex()); + if (unionIndex225 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(225, null); + } else { + if (unionIndex225 == 1) { + Utf8 charSequence225; + Object oldString225 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(225); + if (oldString225 instanceof Utf8) { + charSequence225 = (decoder).readString(((Utf8) oldString225)); + } else { + charSequence225 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(225, charSequence225); + } else { + throw new RuntimeException(("Illegal union index for 'F225': "+ unionIndex225)); + } + } + int unionIndex226 = (decoder.readIndex()); + if (unionIndex226 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(226, null); + } else { + if (unionIndex226 == 1) { + Utf8 charSequence226; + Object oldString226 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(226); + if (oldString226 instanceof Utf8) { + charSequence226 = (decoder).readString(((Utf8) oldString226)); + } else { + charSequence226 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(226, charSequence226); + } else { + throw new RuntimeException(("Illegal union index for 'F226': "+ unionIndex226)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex227 = (decoder.readIndex()); + if (unionIndex227 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(227, null); + } else { + if (unionIndex227 == 1) { + Utf8 charSequence227; + Object oldString227 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(227); + if (oldString227 instanceof Utf8) { + charSequence227 = (decoder).readString(((Utf8) oldString227)); + } else { + charSequence227 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(227, charSequence227); + } else { + throw new RuntimeException(("Illegal union index for 'F227': "+ unionIndex227)); + } + } + int unionIndex228 = (decoder.readIndex()); + if (unionIndex228 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(228, null); + } else { + if (unionIndex228 == 1) { + Utf8 charSequence228; + Object oldString228 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(228); + if (oldString228 instanceof Utf8) { + charSequence228 = (decoder).readString(((Utf8) oldString228)); + } else { + charSequence228 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(228, charSequence228); + } else { + throw new RuntimeException(("Illegal union index for 'F228': "+ unionIndex228)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex229 = (decoder.readIndex()); + if (unionIndex229 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(229, null); + } else { + if (unionIndex229 == 1) { + Utf8 charSequence229; + Object oldString229 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(229); + if (oldString229 instanceof Utf8) { + charSequence229 = (decoder).readString(((Utf8) oldString229)); + } else { + charSequence229 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(229, charSequence229); + } else { + throw new RuntimeException(("Illegal union index for 'F229': "+ unionIndex229)); + } + } + int unionIndex230 = (decoder.readIndex()); + if (unionIndex230 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(230, null); + } else { + if (unionIndex230 == 1) { + Utf8 charSequence230; + Object oldString230 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(230); + if (oldString230 instanceof Utf8) { + charSequence230 = (decoder).readString(((Utf8) oldString230)); + } else { + charSequence230 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(230, charSequence230); + } else { + throw new RuntimeException(("Illegal union index for 'F230': "+ unionIndex230)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex231 = (decoder.readIndex()); + if (unionIndex231 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(231, null); + } else { + if (unionIndex231 == 1) { + Utf8 charSequence231; + Object oldString231 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(231); + if (oldString231 instanceof Utf8) { + charSequence231 = (decoder).readString(((Utf8) oldString231)); + } else { + charSequence231 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(231, charSequence231); + } else { + throw new RuntimeException(("Illegal union index for 'F231': "+ unionIndex231)); + } + } + int unionIndex232 = (decoder.readIndex()); + if (unionIndex232 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(232, null); + } else { + if (unionIndex232 == 1) { + Utf8 charSequence232; + Object oldString232 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(232); + if (oldString232 instanceof Utf8) { + charSequence232 = (decoder).readString(((Utf8) oldString232)); + } else { + charSequence232 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(232, charSequence232); + } else { + throw new RuntimeException(("Illegal union index for 'F232': "+ unionIndex232)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex233 = (decoder.readIndex()); + if (unionIndex233 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(233, null); + } else { + if (unionIndex233 == 1) { + Utf8 charSequence233; + Object oldString233 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(233); + if (oldString233 instanceof Utf8) { + charSequence233 = (decoder).readString(((Utf8) oldString233)); + } else { + charSequence233 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(233, charSequence233); + } else { + throw new RuntimeException(("Illegal union index for 'F233': "+ unionIndex233)); + } + } + int unionIndex234 = (decoder.readIndex()); + if (unionIndex234 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(234, null); + } else { + if (unionIndex234 == 1) { + Utf8 charSequence234; + Object oldString234 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(234); + if (oldString234 instanceof Utf8) { + charSequence234 = (decoder).readString(((Utf8) oldString234)); + } else { + charSequence234 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(234, charSequence234); + } else { + throw new RuntimeException(("Illegal union index for 'F234': "+ unionIndex234)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex235 = (decoder.readIndex()); + if (unionIndex235 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(235, null); + } else { + if (unionIndex235 == 1) { + Utf8 charSequence235; + Object oldString235 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(235); + if (oldString235 instanceof Utf8) { + charSequence235 = (decoder).readString(((Utf8) oldString235)); + } else { + charSequence235 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(235, charSequence235); + } else { + throw new RuntimeException(("Illegal union index for 'F235': "+ unionIndex235)); + } + } + int unionIndex236 = (decoder.readIndex()); + if (unionIndex236 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(236, null); + } else { + if (unionIndex236 == 1) { + Utf8 charSequence236; + Object oldString236 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(236); + if (oldString236 instanceof Utf8) { + charSequence236 = (decoder).readString(((Utf8) oldString236)); + } else { + charSequence236 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(236, charSequence236); + } else { + throw new RuntimeException(("Illegal union index for 'F236': "+ unionIndex236)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex237 = (decoder.readIndex()); + if (unionIndex237 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(237, null); + } else { + if (unionIndex237 == 1) { + Utf8 charSequence237; + Object oldString237 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(237); + if (oldString237 instanceof Utf8) { + charSequence237 = (decoder).readString(((Utf8) oldString237)); + } else { + charSequence237 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(237, charSequence237); + } else { + throw new RuntimeException(("Illegal union index for 'F237': "+ unionIndex237)); + } + } + int unionIndex238 = (decoder.readIndex()); + if (unionIndex238 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(238, null); + } else { + if (unionIndex238 == 1) { + Utf8 charSequence238; + Object oldString238 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(238); + if (oldString238 instanceof Utf8) { + charSequence238 = (decoder).readString(((Utf8) oldString238)); + } else { + charSequence238 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(238, charSequence238); + } else { + throw new RuntimeException(("Illegal union index for 'F238': "+ unionIndex238)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex239 = (decoder.readIndex()); + if (unionIndex239 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(239, null); + } else { + if (unionIndex239 == 1) { + Utf8 charSequence239; + Object oldString239 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(239); + if (oldString239 instanceof Utf8) { + charSequence239 = (decoder).readString(((Utf8) oldString239)); + } else { + charSequence239 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(239, charSequence239); + } else { + throw new RuntimeException(("Illegal union index for 'F239': "+ unionIndex239)); + } + } + int unionIndex240 = (decoder.readIndex()); + if (unionIndex240 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(240, null); + } else { + if (unionIndex240 == 1) { + Utf8 charSequence240; + Object oldString240 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(240); + if (oldString240 instanceof Utf8) { + charSequence240 = (decoder).readString(((Utf8) oldString240)); + } else { + charSequence240 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(240, charSequence240); + } else { + throw new RuntimeException(("Illegal union index for 'F240': "+ unionIndex240)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex241 = (decoder.readIndex()); + if (unionIndex241 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(241, null); + } else { + if (unionIndex241 == 1) { + Utf8 charSequence241; + Object oldString241 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(241); + if (oldString241 instanceof Utf8) { + charSequence241 = (decoder).readString(((Utf8) oldString241)); + } else { + charSequence241 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(241, charSequence241); + } else { + throw new RuntimeException(("Illegal union index for 'F241': "+ unionIndex241)); + } + } + int unionIndex242 = (decoder.readIndex()); + if (unionIndex242 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(242, null); + } else { + if (unionIndex242 == 1) { + Utf8 charSequence242; + Object oldString242 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(242); + if (oldString242 instanceof Utf8) { + charSequence242 = (decoder).readString(((Utf8) oldString242)); + } else { + charSequence242 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(242, charSequence242); + } else { + throw new RuntimeException(("Illegal union index for 'F242': "+ unionIndex242)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex243 = (decoder.readIndex()); + if (unionIndex243 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(243, null); + } else { + if (unionIndex243 == 1) { + Utf8 charSequence243; + Object oldString243 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(243); + if (oldString243 instanceof Utf8) { + charSequence243 = (decoder).readString(((Utf8) oldString243)); + } else { + charSequence243 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(243, charSequence243); + } else { + throw new RuntimeException(("Illegal union index for 'F243': "+ unionIndex243)); + } + } + int unionIndex244 = (decoder.readIndex()); + if (unionIndex244 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(244, null); + } else { + if (unionIndex244 == 1) { + Utf8 charSequence244; + Object oldString244 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(244); + if (oldString244 instanceof Utf8) { + charSequence244 = (decoder).readString(((Utf8) oldString244)); + } else { + charSequence244 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(244, charSequence244); + } else { + throw new RuntimeException(("Illegal union index for 'F244': "+ unionIndex244)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex245 = (decoder.readIndex()); + if (unionIndex245 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(245, null); + } else { + if (unionIndex245 == 1) { + Utf8 charSequence245; + Object oldString245 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(245); + if (oldString245 instanceof Utf8) { + charSequence245 = (decoder).readString(((Utf8) oldString245)); + } else { + charSequence245 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(245, charSequence245); + } else { + throw new RuntimeException(("Illegal union index for 'F245': "+ unionIndex245)); + } + } + int unionIndex246 = (decoder.readIndex()); + if (unionIndex246 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(246, null); + } else { + if (unionIndex246 == 1) { + Utf8 charSequence246; + Object oldString246 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(246); + if (oldString246 instanceof Utf8) { + charSequence246 = (decoder).readString(((Utf8) oldString246)); + } else { + charSequence246 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(246, charSequence246); + } else { + throw new RuntimeException(("Illegal union index for 'F246': "+ unionIndex246)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex247 = (decoder.readIndex()); + if (unionIndex247 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(247, null); + } else { + if (unionIndex247 == 1) { + Utf8 charSequence247; + Object oldString247 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(247); + if (oldString247 instanceof Utf8) { + charSequence247 = (decoder).readString(((Utf8) oldString247)); + } else { + charSequence247 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(247, charSequence247); + } else { + throw new RuntimeException(("Illegal union index for 'F247': "+ unionIndex247)); + } + } + int unionIndex248 = (decoder.readIndex()); + if (unionIndex248 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(248, null); + } else { + if (unionIndex248 == 1) { + Utf8 charSequence248; + Object oldString248 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(248); + if (oldString248 instanceof Utf8) { + charSequence248 = (decoder).readString(((Utf8) oldString248)); + } else { + charSequence248 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(248, charSequence248); + } else { + throw new RuntimeException(("Illegal union index for 'F248': "+ unionIndex248)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex249 = (decoder.readIndex()); + if (unionIndex249 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(249, null); + } else { + if (unionIndex249 == 1) { + Utf8 charSequence249; + Object oldString249 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(249); + if (oldString249 instanceof Utf8) { + charSequence249 = (decoder).readString(((Utf8) oldString249)); + } else { + charSequence249 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(249, charSequence249); + } else { + throw new RuntimeException(("Illegal union index for 'F249': "+ unionIndex249)); + } + } + int unionIndex250 = (decoder.readIndex()); + if (unionIndex250 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(250, null); + } else { + if (unionIndex250 == 1) { + Utf8 charSequence250; + Object oldString250 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(250); + if (oldString250 instanceof Utf8) { + charSequence250 = (decoder).readString(((Utf8) oldString250)); + } else { + charSequence250 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(250, charSequence250); + } else { + throw new RuntimeException(("Illegal union index for 'F250': "+ unionIndex250)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex251 = (decoder.readIndex()); + if (unionIndex251 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(251, null); + } else { + if (unionIndex251 == 1) { + Utf8 charSequence251; + Object oldString251 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(251); + if (oldString251 instanceof Utf8) { + charSequence251 = (decoder).readString(((Utf8) oldString251)); + } else { + charSequence251 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(251, charSequence251); + } else { + throw new RuntimeException(("Illegal union index for 'F251': "+ unionIndex251)); + } + } + int unionIndex252 = (decoder.readIndex()); + if (unionIndex252 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(252, null); + } else { + if (unionIndex252 == 1) { + Utf8 charSequence252; + Object oldString252 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(252); + if (oldString252 instanceof Utf8) { + charSequence252 = (decoder).readString(((Utf8) oldString252)); + } else { + charSequence252 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(252, charSequence252); + } else { + throw new RuntimeException(("Illegal union index for 'F252': "+ unionIndex252)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex253 = (decoder.readIndex()); + if (unionIndex253 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(253, null); + } else { + if (unionIndex253 == 1) { + Utf8 charSequence253; + Object oldString253 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(253); + if (oldString253 instanceof Utf8) { + charSequence253 = (decoder).readString(((Utf8) oldString253)); + } else { + charSequence253 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(253, charSequence253); + } else { + throw new RuntimeException(("Illegal union index for 'F253': "+ unionIndex253)); + } + } + int unionIndex254 = (decoder.readIndex()); + if (unionIndex254 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(254, null); + } else { + if (unionIndex254 == 1) { + Utf8 charSequence254; + Object oldString254 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(254); + if (oldString254 instanceof Utf8) { + charSequence254 = (decoder).readString(((Utf8) oldString254)); + } else { + charSequence254 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(254, charSequence254); + } else { + throw new RuntimeException(("Illegal union index for 'F254': "+ unionIndex254)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex255 = (decoder.readIndex()); + if (unionIndex255 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(255, null); + } else { + if (unionIndex255 == 1) { + Utf8 charSequence255; + Object oldString255 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(255); + if (oldString255 instanceof Utf8) { + charSequence255 = (decoder).readString(((Utf8) oldString255)); + } else { + charSequence255 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(255, charSequence255); + } else { + throw new RuntimeException(("Illegal union index for 'F255': "+ unionIndex255)); + } + } + int unionIndex256 = (decoder.readIndex()); + if (unionIndex256 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(256, null); + } else { + if (unionIndex256 == 1) { + Utf8 charSequence256; + Object oldString256 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(256); + if (oldString256 instanceof Utf8) { + charSequence256 = (decoder).readString(((Utf8) oldString256)); + } else { + charSequence256 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(256, charSequence256); + } else { + throw new RuntimeException(("Illegal union index for 'F256': "+ unionIndex256)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex257 = (decoder.readIndex()); + if (unionIndex257 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(257, null); + } else { + if (unionIndex257 == 1) { + Utf8 charSequence257; + Object oldString257 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(257); + if (oldString257 instanceof Utf8) { + charSequence257 = (decoder).readString(((Utf8) oldString257)); + } else { + charSequence257 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(257, charSequence257); + } else { + throw new RuntimeException(("Illegal union index for 'F257': "+ unionIndex257)); + } + } + int unionIndex258 = (decoder.readIndex()); + if (unionIndex258 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(258, null); + } else { + if (unionIndex258 == 1) { + Utf8 charSequence258; + Object oldString258 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(258); + if (oldString258 instanceof Utf8) { + charSequence258 = (decoder).readString(((Utf8) oldString258)); + } else { + charSequence258 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(258, charSequence258); + } else { + throw new RuntimeException(("Illegal union index for 'F258': "+ unionIndex258)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex259 = (decoder.readIndex()); + if (unionIndex259 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(259, null); + } else { + if (unionIndex259 == 1) { + Utf8 charSequence259; + Object oldString259 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(259); + if (oldString259 instanceof Utf8) { + charSequence259 = (decoder).readString(((Utf8) oldString259)); + } else { + charSequence259 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(259, charSequence259); + } else { + throw new RuntimeException(("Illegal union index for 'F259': "+ unionIndex259)); + } + } + int unionIndex260 = (decoder.readIndex()); + if (unionIndex260 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(260, null); + } else { + if (unionIndex260 == 1) { + Utf8 charSequence260; + Object oldString260 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(260); + if (oldString260 instanceof Utf8) { + charSequence260 = (decoder).readString(((Utf8) oldString260)); + } else { + charSequence260 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(260, charSequence260); + } else { + throw new RuntimeException(("Illegal union index for 'F260': "+ unionIndex260)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex261 = (decoder.readIndex()); + if (unionIndex261 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(261, null); + } else { + if (unionIndex261 == 1) { + Utf8 charSequence261; + Object oldString261 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(261); + if (oldString261 instanceof Utf8) { + charSequence261 = (decoder).readString(((Utf8) oldString261)); + } else { + charSequence261 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(261, charSequence261); + } else { + throw new RuntimeException(("Illegal union index for 'F261': "+ unionIndex261)); + } + } + int unionIndex262 = (decoder.readIndex()); + if (unionIndex262 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(262, null); + } else { + if (unionIndex262 == 1) { + Utf8 charSequence262; + Object oldString262 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(262); + if (oldString262 instanceof Utf8) { + charSequence262 = (decoder).readString(((Utf8) oldString262)); + } else { + charSequence262 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(262, charSequence262); + } else { + throw new RuntimeException(("Illegal union index for 'F262': "+ unionIndex262)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex263 = (decoder.readIndex()); + if (unionIndex263 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(263, null); + } else { + if (unionIndex263 == 1) { + Utf8 charSequence263; + Object oldString263 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(263); + if (oldString263 instanceof Utf8) { + charSequence263 = (decoder).readString(((Utf8) oldString263)); + } else { + charSequence263 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(263, charSequence263); + } else { + throw new RuntimeException(("Illegal union index for 'F263': "+ unionIndex263)); + } + } + int unionIndex264 = (decoder.readIndex()); + if (unionIndex264 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(264, null); + } else { + if (unionIndex264 == 1) { + Utf8 charSequence264; + Object oldString264 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(264); + if (oldString264 instanceof Utf8) { + charSequence264 = (decoder).readString(((Utf8) oldString264)); + } else { + charSequence264 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(264, charSequence264); + } else { + throw new RuntimeException(("Illegal union index for 'F264': "+ unionIndex264)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex265 = (decoder.readIndex()); + if (unionIndex265 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(265, null); + } else { + if (unionIndex265 == 1) { + Utf8 charSequence265; + Object oldString265 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(265); + if (oldString265 instanceof Utf8) { + charSequence265 = (decoder).readString(((Utf8) oldString265)); + } else { + charSequence265 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(265, charSequence265); + } else { + throw new RuntimeException(("Illegal union index for 'F265': "+ unionIndex265)); + } + } + int unionIndex266 = (decoder.readIndex()); + if (unionIndex266 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(266, null); + } else { + if (unionIndex266 == 1) { + Utf8 charSequence266; + Object oldString266 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(266); + if (oldString266 instanceof Utf8) { + charSequence266 = (decoder).readString(((Utf8) oldString266)); + } else { + charSequence266 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(266, charSequence266); + } else { + throw new RuntimeException(("Illegal union index for 'F266': "+ unionIndex266)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex267 = (decoder.readIndex()); + if (unionIndex267 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(267, null); + } else { + if (unionIndex267 == 1) { + Utf8 charSequence267; + Object oldString267 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(267); + if (oldString267 instanceof Utf8) { + charSequence267 = (decoder).readString(((Utf8) oldString267)); + } else { + charSequence267 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(267, charSequence267); + } else { + throw new RuntimeException(("Illegal union index for 'F267': "+ unionIndex267)); + } + } + int unionIndex268 = (decoder.readIndex()); + if (unionIndex268 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(268, null); + } else { + if (unionIndex268 == 1) { + Utf8 charSequence268; + Object oldString268 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(268); + if (oldString268 instanceof Utf8) { + charSequence268 = (decoder).readString(((Utf8) oldString268)); + } else { + charSequence268 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(268, charSequence268); + } else { + throw new RuntimeException(("Illegal union index for 'F268': "+ unionIndex268)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex269 = (decoder.readIndex()); + if (unionIndex269 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(269, null); + } else { + if (unionIndex269 == 1) { + Utf8 charSequence269; + Object oldString269 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(269); + if (oldString269 instanceof Utf8) { + charSequence269 = (decoder).readString(((Utf8) oldString269)); + } else { + charSequence269 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(269, charSequence269); + } else { + throw new RuntimeException(("Illegal union index for 'F269': "+ unionIndex269)); + } + } + int unionIndex270 = (decoder.readIndex()); + if (unionIndex270 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(270, null); + } else { + if (unionIndex270 == 1) { + Utf8 charSequence270; + Object oldString270 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(270); + if (oldString270 instanceof Utf8) { + charSequence270 = (decoder).readString(((Utf8) oldString270)); + } else { + charSequence270 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(270, charSequence270); + } else { + throw new RuntimeException(("Illegal union index for 'F270': "+ unionIndex270)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex271 = (decoder.readIndex()); + if (unionIndex271 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(271, null); + } else { + if (unionIndex271 == 1) { + Utf8 charSequence271; + Object oldString271 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(271); + if (oldString271 instanceof Utf8) { + charSequence271 = (decoder).readString(((Utf8) oldString271)); + } else { + charSequence271 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(271, charSequence271); + } else { + throw new RuntimeException(("Illegal union index for 'F271': "+ unionIndex271)); + } + } + int unionIndex272 = (decoder.readIndex()); + if (unionIndex272 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(272, null); + } else { + if (unionIndex272 == 1) { + Utf8 charSequence272; + Object oldString272 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(272); + if (oldString272 instanceof Utf8) { + charSequence272 = (decoder).readString(((Utf8) oldString272)); + } else { + charSequence272 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(272, charSequence272); + } else { + throw new RuntimeException(("Illegal union index for 'F272': "+ unionIndex272)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex273 = (decoder.readIndex()); + if (unionIndex273 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(273, null); + } else { + if (unionIndex273 == 1) { + Utf8 charSequence273; + Object oldString273 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(273); + if (oldString273 instanceof Utf8) { + charSequence273 = (decoder).readString(((Utf8) oldString273)); + } else { + charSequence273 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(273, charSequence273); + } else { + throw new RuntimeException(("Illegal union index for 'F273': "+ unionIndex273)); + } + } + int unionIndex274 = (decoder.readIndex()); + if (unionIndex274 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(274, null); + } else { + if (unionIndex274 == 1) { + Utf8 charSequence274; + Object oldString274 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(274); + if (oldString274 instanceof Utf8) { + charSequence274 = (decoder).readString(((Utf8) oldString274)); + } else { + charSequence274 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(274, charSequence274); + } else { + throw new RuntimeException(("Illegal union index for 'F274': "+ unionIndex274)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex275 = (decoder.readIndex()); + if (unionIndex275 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(275, null); + } else { + if (unionIndex275 == 1) { + Utf8 charSequence275; + Object oldString275 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(275); + if (oldString275 instanceof Utf8) { + charSequence275 = (decoder).readString(((Utf8) oldString275)); + } else { + charSequence275 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(275, charSequence275); + } else { + throw new RuntimeException(("Illegal union index for 'F275': "+ unionIndex275)); + } + } + int unionIndex276 = (decoder.readIndex()); + if (unionIndex276 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(276, null); + } else { + if (unionIndex276 == 1) { + Utf8 charSequence276; + Object oldString276 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(276); + if (oldString276 instanceof Utf8) { + charSequence276 = (decoder).readString(((Utf8) oldString276)); + } else { + charSequence276 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(276, charSequence276); + } else { + throw new RuntimeException(("Illegal union index for 'F276': "+ unionIndex276)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex277 = (decoder.readIndex()); + if (unionIndex277 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(277, null); + } else { + if (unionIndex277 == 1) { + Utf8 charSequence277; + Object oldString277 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(277); + if (oldString277 instanceof Utf8) { + charSequence277 = (decoder).readString(((Utf8) oldString277)); + } else { + charSequence277 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(277, charSequence277); + } else { + throw new RuntimeException(("Illegal union index for 'F277': "+ unionIndex277)); + } + } + int unionIndex278 = (decoder.readIndex()); + if (unionIndex278 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(278, null); + } else { + if (unionIndex278 == 1) { + Utf8 charSequence278; + Object oldString278 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(278); + if (oldString278 instanceof Utf8) { + charSequence278 = (decoder).readString(((Utf8) oldString278)); + } else { + charSequence278 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(278, charSequence278); + } else { + throw new RuntimeException(("Illegal union index for 'F278': "+ unionIndex278)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex279 = (decoder.readIndex()); + if (unionIndex279 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(279, null); + } else { + if (unionIndex279 == 1) { + Utf8 charSequence279; + Object oldString279 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(279); + if (oldString279 instanceof Utf8) { + charSequence279 = (decoder).readString(((Utf8) oldString279)); + } else { + charSequence279 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(279, charSequence279); + } else { + throw new RuntimeException(("Illegal union index for 'F279': "+ unionIndex279)); + } + } + int unionIndex280 = (decoder.readIndex()); + if (unionIndex280 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(280, null); + } else { + if (unionIndex280 == 1) { + Utf8 charSequence280; + Object oldString280 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(280); + if (oldString280 instanceof Utf8) { + charSequence280 = (decoder).readString(((Utf8) oldString280)); + } else { + charSequence280 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(280, charSequence280); + } else { + throw new RuntimeException(("Illegal union index for 'F280': "+ unionIndex280)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex281 = (decoder.readIndex()); + if (unionIndex281 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(281, null); + } else { + if (unionIndex281 == 1) { + Utf8 charSequence281; + Object oldString281 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(281); + if (oldString281 instanceof Utf8) { + charSequence281 = (decoder).readString(((Utf8) oldString281)); + } else { + charSequence281 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(281, charSequence281); + } else { + throw new RuntimeException(("Illegal union index for 'F281': "+ unionIndex281)); + } + } + int unionIndex282 = (decoder.readIndex()); + if (unionIndex282 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(282, null); + } else { + if (unionIndex282 == 1) { + Utf8 charSequence282; + Object oldString282 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(282); + if (oldString282 instanceof Utf8) { + charSequence282 = (decoder).readString(((Utf8) oldString282)); + } else { + charSequence282 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(282, charSequence282); + } else { + throw new RuntimeException(("Illegal union index for 'F282': "+ unionIndex282)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex283 = (decoder.readIndex()); + if (unionIndex283 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(283, null); + } else { + if (unionIndex283 == 1) { + Utf8 charSequence283; + Object oldString283 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(283); + if (oldString283 instanceof Utf8) { + charSequence283 = (decoder).readString(((Utf8) oldString283)); + } else { + charSequence283 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(283, charSequence283); + } else { + throw new RuntimeException(("Illegal union index for 'F283': "+ unionIndex283)); + } + } + int unionIndex284 = (decoder.readIndex()); + if (unionIndex284 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(284, null); + } else { + if (unionIndex284 == 1) { + Utf8 charSequence284; + Object oldString284 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(284); + if (oldString284 instanceof Utf8) { + charSequence284 = (decoder).readString(((Utf8) oldString284)); + } else { + charSequence284 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(284, charSequence284); + } else { + throw new RuntimeException(("Illegal union index for 'F284': "+ unionIndex284)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex285 = (decoder.readIndex()); + if (unionIndex285 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(285, null); + } else { + if (unionIndex285 == 1) { + Utf8 charSequence285; + Object oldString285 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(285); + if (oldString285 instanceof Utf8) { + charSequence285 = (decoder).readString(((Utf8) oldString285)); + } else { + charSequence285 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(285, charSequence285); + } else { + throw new RuntimeException(("Illegal union index for 'F285': "+ unionIndex285)); + } + } + int unionIndex286 = (decoder.readIndex()); + if (unionIndex286 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(286, null); + } else { + if (unionIndex286 == 1) { + Utf8 charSequence286; + Object oldString286 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(286); + if (oldString286 instanceof Utf8) { + charSequence286 = (decoder).readString(((Utf8) oldString286)); + } else { + charSequence286 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(286, charSequence286); + } else { + throw new RuntimeException(("Illegal union index for 'F286': "+ unionIndex286)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex287 = (decoder.readIndex()); + if (unionIndex287 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(287, null); + } else { + if (unionIndex287 == 1) { + Utf8 charSequence287; + Object oldString287 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(287); + if (oldString287 instanceof Utf8) { + charSequence287 = (decoder).readString(((Utf8) oldString287)); + } else { + charSequence287 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(287, charSequence287); + } else { + throw new RuntimeException(("Illegal union index for 'F287': "+ unionIndex287)); + } + } + int unionIndex288 = (decoder.readIndex()); + if (unionIndex288 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(288, null); + } else { + if (unionIndex288 == 1) { + Utf8 charSequence288; + Object oldString288 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(288); + if (oldString288 instanceof Utf8) { + charSequence288 = (decoder).readString(((Utf8) oldString288)); + } else { + charSequence288 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(288, charSequence288); + } else { + throw new RuntimeException(("Illegal union index for 'F288': "+ unionIndex288)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex289 = (decoder.readIndex()); + if (unionIndex289 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(289, null); + } else { + if (unionIndex289 == 1) { + Utf8 charSequence289; + Object oldString289 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(289); + if (oldString289 instanceof Utf8) { + charSequence289 = (decoder).readString(((Utf8) oldString289)); + } else { + charSequence289 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(289, charSequence289); + } else { + throw new RuntimeException(("Illegal union index for 'F289': "+ unionIndex289)); + } + } + int unionIndex290 = (decoder.readIndex()); + if (unionIndex290 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(290, null); + } else { + if (unionIndex290 == 1) { + Utf8 charSequence290; + Object oldString290 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(290); + if (oldString290 instanceof Utf8) { + charSequence290 = (decoder).readString(((Utf8) oldString290)); + } else { + charSequence290 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(290, charSequence290); + } else { + throw new RuntimeException(("Illegal union index for 'F290': "+ unionIndex290)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex291 = (decoder.readIndex()); + if (unionIndex291 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(291, null); + } else { + if (unionIndex291 == 1) { + Utf8 charSequence291; + Object oldString291 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(291); + if (oldString291 instanceof Utf8) { + charSequence291 = (decoder).readString(((Utf8) oldString291)); + } else { + charSequence291 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(291, charSequence291); + } else { + throw new RuntimeException(("Illegal union index for 'F291': "+ unionIndex291)); + } + } + int unionIndex292 = (decoder.readIndex()); + if (unionIndex292 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(292, null); + } else { + if (unionIndex292 == 1) { + Utf8 charSequence292; + Object oldString292 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(292); + if (oldString292 instanceof Utf8) { + charSequence292 = (decoder).readString(((Utf8) oldString292)); + } else { + charSequence292 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(292, charSequence292); + } else { + throw new RuntimeException(("Illegal union index for 'F292': "+ unionIndex292)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex293 = (decoder.readIndex()); + if (unionIndex293 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(293, null); + } else { + if (unionIndex293 == 1) { + Utf8 charSequence293; + Object oldString293 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(293); + if (oldString293 instanceof Utf8) { + charSequence293 = (decoder).readString(((Utf8) oldString293)); + } else { + charSequence293 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(293, charSequence293); + } else { + throw new RuntimeException(("Illegal union index for 'F293': "+ unionIndex293)); + } + } + int unionIndex294 = (decoder.readIndex()); + if (unionIndex294 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(294, null); + } else { + if (unionIndex294 == 1) { + Utf8 charSequence294; + Object oldString294 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(294); + if (oldString294 instanceof Utf8) { + charSequence294 = (decoder).readString(((Utf8) oldString294)); + } else { + charSequence294 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(294, charSequence294); + } else { + throw new RuntimeException(("Illegal union index for 'F294': "+ unionIndex294)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex295 = (decoder.readIndex()); + if (unionIndex295 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(295, null); + } else { + if (unionIndex295 == 1) { + Utf8 charSequence295; + Object oldString295 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(295); + if (oldString295 instanceof Utf8) { + charSequence295 = (decoder).readString(((Utf8) oldString295)); + } else { + charSequence295 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(295, charSequence295); + } else { + throw new RuntimeException(("Illegal union index for 'F295': "+ unionIndex295)); + } + } + int unionIndex296 = (decoder.readIndex()); + if (unionIndex296 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(296, null); + } else { + if (unionIndex296 == 1) { + Utf8 charSequence296; + Object oldString296 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(296); + if (oldString296 instanceof Utf8) { + charSequence296 = (decoder).readString(((Utf8) oldString296)); + } else { + charSequence296 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(296, charSequence296); + } else { + throw new RuntimeException(("Illegal union index for 'F296': "+ unionIndex296)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex297 = (decoder.readIndex()); + if (unionIndex297 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(297, null); + } else { + if (unionIndex297 == 1) { + Utf8 charSequence297; + Object oldString297 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(297); + if (oldString297 instanceof Utf8) { + charSequence297 = (decoder).readString(((Utf8) oldString297)); + } else { + charSequence297 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(297, charSequence297); + } else { + throw new RuntimeException(("Illegal union index for 'F297': "+ unionIndex297)); + } + } + int unionIndex298 = (decoder.readIndex()); + if (unionIndex298 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(298, null); + } else { + if (unionIndex298 == 1) { + Utf8 charSequence298; + Object oldString298 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(298); + if (oldString298 instanceof Utf8) { + charSequence298 = (decoder).readString(((Utf8) oldString298)); + } else { + charSequence298 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(298, charSequence298); + } else { + throw new RuntimeException(("Illegal union index for 'F298': "+ unionIndex298)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex299 = (decoder.readIndex()); + if (unionIndex299 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(299, null); + } else { + if (unionIndex299 == 1) { + Utf8 charSequence299; + Object oldString299 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(299); + if (oldString299 instanceof Utf8) { + charSequence299 = (decoder).readString(((Utf8) oldString299)); + } else { + charSequence299 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(299, charSequence299); + } else { + throw new RuntimeException(("Illegal union index for 'F299': "+ unionIndex299)); + } + } + int unionIndex300 = (decoder.readIndex()); + if (unionIndex300 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(300, null); + } else { + if (unionIndex300 == 1) { + Utf8 charSequence300; + Object oldString300 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(300); + if (oldString300 instanceof Utf8) { + charSequence300 = (decoder).readString(((Utf8) oldString300)); + } else { + charSequence300 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(300, charSequence300); + } else { + throw new RuntimeException(("Illegal union index for 'F300': "+ unionIndex300)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex301 = (decoder.readIndex()); + if (unionIndex301 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(301, null); + } else { + if (unionIndex301 == 1) { + Utf8 charSequence301; + Object oldString301 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(301); + if (oldString301 instanceof Utf8) { + charSequence301 = (decoder).readString(((Utf8) oldString301)); + } else { + charSequence301 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(301, charSequence301); + } else { + throw new RuntimeException(("Illegal union index for 'F301': "+ unionIndex301)); + } + } + int unionIndex302 = (decoder.readIndex()); + if (unionIndex302 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(302, null); + } else { + if (unionIndex302 == 1) { + Utf8 charSequence302; + Object oldString302 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(302); + if (oldString302 instanceof Utf8) { + charSequence302 = (decoder).readString(((Utf8) oldString302)); + } else { + charSequence302 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(302, charSequence302); + } else { + throw new RuntimeException(("Illegal union index for 'F302': "+ unionIndex302)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex303 = (decoder.readIndex()); + if (unionIndex303 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(303, null); + } else { + if (unionIndex303 == 1) { + Utf8 charSequence303; + Object oldString303 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(303); + if (oldString303 instanceof Utf8) { + charSequence303 = (decoder).readString(((Utf8) oldString303)); + } else { + charSequence303 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(303, charSequence303); + } else { + throw new RuntimeException(("Illegal union index for 'F303': "+ unionIndex303)); + } + } + int unionIndex304 = (decoder.readIndex()); + if (unionIndex304 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(304, null); + } else { + if (unionIndex304 == 1) { + Utf8 charSequence304; + Object oldString304 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(304); + if (oldString304 instanceof Utf8) { + charSequence304 = (decoder).readString(((Utf8) oldString304)); + } else { + charSequence304 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(304, charSequence304); + } else { + throw new RuntimeException(("Illegal union index for 'F304': "+ unionIndex304)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex305 = (decoder.readIndex()); + if (unionIndex305 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(305, null); + } else { + if (unionIndex305 == 1) { + Utf8 charSequence305; + Object oldString305 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(305); + if (oldString305 instanceof Utf8) { + charSequence305 = (decoder).readString(((Utf8) oldString305)); + } else { + charSequence305 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(305, charSequence305); + } else { + throw new RuntimeException(("Illegal union index for 'F305': "+ unionIndex305)); + } + } + int unionIndex306 = (decoder.readIndex()); + if (unionIndex306 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(306, null); + } else { + if (unionIndex306 == 1) { + Utf8 charSequence306; + Object oldString306 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(306); + if (oldString306 instanceof Utf8) { + charSequence306 = (decoder).readString(((Utf8) oldString306)); + } else { + charSequence306 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(306, charSequence306); + } else { + throw new RuntimeException(("Illegal union index for 'F306': "+ unionIndex306)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex307 = (decoder.readIndex()); + if (unionIndex307 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(307, null); + } else { + if (unionIndex307 == 1) { + Utf8 charSequence307; + Object oldString307 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(307); + if (oldString307 instanceof Utf8) { + charSequence307 = (decoder).readString(((Utf8) oldString307)); + } else { + charSequence307 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(307, charSequence307); + } else { + throw new RuntimeException(("Illegal union index for 'F307': "+ unionIndex307)); + } + } + int unionIndex308 = (decoder.readIndex()); + if (unionIndex308 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(308, null); + } else { + if (unionIndex308 == 1) { + Utf8 charSequence308; + Object oldString308 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(308); + if (oldString308 instanceof Utf8) { + charSequence308 = (decoder).readString(((Utf8) oldString308)); + } else { + charSequence308 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(308, charSequence308); + } else { + throw new RuntimeException(("Illegal union index for 'F308': "+ unionIndex308)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex309 = (decoder.readIndex()); + if (unionIndex309 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(309, null); + } else { + if (unionIndex309 == 1) { + Utf8 charSequence309; + Object oldString309 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(309); + if (oldString309 instanceof Utf8) { + charSequence309 = (decoder).readString(((Utf8) oldString309)); + } else { + charSequence309 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(309, charSequence309); + } else { + throw new RuntimeException(("Illegal union index for 'F309': "+ unionIndex309)); + } + } + int unionIndex310 = (decoder.readIndex()); + if (unionIndex310 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(310, null); + } else { + if (unionIndex310 == 1) { + Utf8 charSequence310; + Object oldString310 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(310); + if (oldString310 instanceof Utf8) { + charSequence310 = (decoder).readString(((Utf8) oldString310)); + } else { + charSequence310 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(310, charSequence310); + } else { + throw new RuntimeException(("Illegal union index for 'F310': "+ unionIndex310)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex311 = (decoder.readIndex()); + if (unionIndex311 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(311, null); + } else { + if (unionIndex311 == 1) { + Utf8 charSequence311; + Object oldString311 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(311); + if (oldString311 instanceof Utf8) { + charSequence311 = (decoder).readString(((Utf8) oldString311)); + } else { + charSequence311 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(311, charSequence311); + } else { + throw new RuntimeException(("Illegal union index for 'F311': "+ unionIndex311)); + } + } + int unionIndex312 = (decoder.readIndex()); + if (unionIndex312 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(312, null); + } else { + if (unionIndex312 == 1) { + Utf8 charSequence312; + Object oldString312 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(312); + if (oldString312 instanceof Utf8) { + charSequence312 = (decoder).readString(((Utf8) oldString312)); + } else { + charSequence312 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(312, charSequence312); + } else { + throw new RuntimeException(("Illegal union index for 'F312': "+ unionIndex312)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex313 = (decoder.readIndex()); + if (unionIndex313 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(313, null); + } else { + if (unionIndex313 == 1) { + Utf8 charSequence313; + Object oldString313 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(313); + if (oldString313 instanceof Utf8) { + charSequence313 = (decoder).readString(((Utf8) oldString313)); + } else { + charSequence313 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(313, charSequence313); + } else { + throw new RuntimeException(("Illegal union index for 'F313': "+ unionIndex313)); + } + } + int unionIndex314 = (decoder.readIndex()); + if (unionIndex314 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(314, null); + } else { + if (unionIndex314 == 1) { + Utf8 charSequence314; + Object oldString314 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(314); + if (oldString314 instanceof Utf8) { + charSequence314 = (decoder).readString(((Utf8) oldString314)); + } else { + charSequence314 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(314, charSequence314); + } else { + throw new RuntimeException(("Illegal union index for 'F314': "+ unionIndex314)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex315 = (decoder.readIndex()); + if (unionIndex315 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(315, null); + } else { + if (unionIndex315 == 1) { + Utf8 charSequence315; + Object oldString315 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(315); + if (oldString315 instanceof Utf8) { + charSequence315 = (decoder).readString(((Utf8) oldString315)); + } else { + charSequence315 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(315, charSequence315); + } else { + throw new RuntimeException(("Illegal union index for 'F315': "+ unionIndex315)); + } + } + int unionIndex316 = (decoder.readIndex()); + if (unionIndex316 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(316, null); + } else { + if (unionIndex316 == 1) { + Utf8 charSequence316; + Object oldString316 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(316); + if (oldString316 instanceof Utf8) { + charSequence316 = (decoder).readString(((Utf8) oldString316)); + } else { + charSequence316 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(316, charSequence316); + } else { + throw new RuntimeException(("Illegal union index for 'F316': "+ unionIndex316)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex317 = (decoder.readIndex()); + if (unionIndex317 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(317, null); + } else { + if (unionIndex317 == 1) { + Utf8 charSequence317; + Object oldString317 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(317); + if (oldString317 instanceof Utf8) { + charSequence317 = (decoder).readString(((Utf8) oldString317)); + } else { + charSequence317 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(317, charSequence317); + } else { + throw new RuntimeException(("Illegal union index for 'F317': "+ unionIndex317)); + } + } + int unionIndex318 = (decoder.readIndex()); + if (unionIndex318 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(318, null); + } else { + if (unionIndex318 == 1) { + Utf8 charSequence318; + Object oldString318 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(318); + if (oldString318 instanceof Utf8) { + charSequence318 = (decoder).readString(((Utf8) oldString318)); + } else { + charSequence318 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(318, charSequence318); + } else { + throw new RuntimeException(("Illegal union index for 'F318': "+ unionIndex318)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex319 = (decoder.readIndex()); + if (unionIndex319 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(319, null); + } else { + if (unionIndex319 == 1) { + Utf8 charSequence319; + Object oldString319 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(319); + if (oldString319 instanceof Utf8) { + charSequence319 = (decoder).readString(((Utf8) oldString319)); + } else { + charSequence319 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(319, charSequence319); + } else { + throw new RuntimeException(("Illegal union index for 'F319': "+ unionIndex319)); + } + } + int unionIndex320 = (decoder.readIndex()); + if (unionIndex320 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(320, null); + } else { + if (unionIndex320 == 1) { + Utf8 charSequence320; + Object oldString320 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(320); + if (oldString320 instanceof Utf8) { + charSequence320 = (decoder).readString(((Utf8) oldString320)); + } else { + charSequence320 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(320, charSequence320); + } else { + throw new RuntimeException(("Illegal union index for 'F320': "+ unionIndex320)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex321 = (decoder.readIndex()); + if (unionIndex321 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(321, null); + } else { + if (unionIndex321 == 1) { + Utf8 charSequence321; + Object oldString321 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(321); + if (oldString321 instanceof Utf8) { + charSequence321 = (decoder).readString(((Utf8) oldString321)); + } else { + charSequence321 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(321, charSequence321); + } else { + throw new RuntimeException(("Illegal union index for 'F321': "+ unionIndex321)); + } + } + int unionIndex322 = (decoder.readIndex()); + if (unionIndex322 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(322, null); + } else { + if (unionIndex322 == 1) { + Utf8 charSequence322; + Object oldString322 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(322); + if (oldString322 instanceof Utf8) { + charSequence322 = (decoder).readString(((Utf8) oldString322)); + } else { + charSequence322 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(322, charSequence322); + } else { + throw new RuntimeException(("Illegal union index for 'F322': "+ unionIndex322)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex323 = (decoder.readIndex()); + if (unionIndex323 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(323, null); + } else { + if (unionIndex323 == 1) { + Utf8 charSequence323; + Object oldString323 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(323); + if (oldString323 instanceof Utf8) { + charSequence323 = (decoder).readString(((Utf8) oldString323)); + } else { + charSequence323 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(323, charSequence323); + } else { + throw new RuntimeException(("Illegal union index for 'F323': "+ unionIndex323)); + } + } + int unionIndex324 = (decoder.readIndex()); + if (unionIndex324 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(324, null); + } else { + if (unionIndex324 == 1) { + Utf8 charSequence324; + Object oldString324 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(324); + if (oldString324 instanceof Utf8) { + charSequence324 = (decoder).readString(((Utf8) oldString324)); + } else { + charSequence324 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(324, charSequence324); + } else { + throw new RuntimeException(("Illegal union index for 'F324': "+ unionIndex324)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex325 = (decoder.readIndex()); + if (unionIndex325 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(325, null); + } else { + if (unionIndex325 == 1) { + Utf8 charSequence325; + Object oldString325 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(325); + if (oldString325 instanceof Utf8) { + charSequence325 = (decoder).readString(((Utf8) oldString325)); + } else { + charSequence325 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(325, charSequence325); + } else { + throw new RuntimeException(("Illegal union index for 'F325': "+ unionIndex325)); + } + } + int unionIndex326 = (decoder.readIndex()); + if (unionIndex326 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(326, null); + } else { + if (unionIndex326 == 1) { + Utf8 charSequence326; + Object oldString326 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(326); + if (oldString326 instanceof Utf8) { + charSequence326 = (decoder).readString(((Utf8) oldString326)); + } else { + charSequence326 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(326, charSequence326); + } else { + throw new RuntimeException(("Illegal union index for 'F326': "+ unionIndex326)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex327 = (decoder.readIndex()); + if (unionIndex327 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(327, null); + } else { + if (unionIndex327 == 1) { + Utf8 charSequence327; + Object oldString327 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(327); + if (oldString327 instanceof Utf8) { + charSequence327 = (decoder).readString(((Utf8) oldString327)); + } else { + charSequence327 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(327, charSequence327); + } else { + throw new RuntimeException(("Illegal union index for 'F327': "+ unionIndex327)); + } + } + int unionIndex328 = (decoder.readIndex()); + if (unionIndex328 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(328, null); + } else { + if (unionIndex328 == 1) { + Utf8 charSequence328; + Object oldString328 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(328); + if (oldString328 instanceof Utf8) { + charSequence328 = (decoder).readString(((Utf8) oldString328)); + } else { + charSequence328 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(328, charSequence328); + } else { + throw new RuntimeException(("Illegal union index for 'F328': "+ unionIndex328)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex329 = (decoder.readIndex()); + if (unionIndex329 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(329, null); + } else { + if (unionIndex329 == 1) { + Utf8 charSequence329; + Object oldString329 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(329); + if (oldString329 instanceof Utf8) { + charSequence329 = (decoder).readString(((Utf8) oldString329)); + } else { + charSequence329 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(329, charSequence329); + } else { + throw new RuntimeException(("Illegal union index for 'F329': "+ unionIndex329)); + } + } + int unionIndex330 = (decoder.readIndex()); + if (unionIndex330 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(330, null); + } else { + if (unionIndex330 == 1) { + Utf8 charSequence330; + Object oldString330 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(330); + if (oldString330 instanceof Utf8) { + charSequence330 = (decoder).readString(((Utf8) oldString330)); + } else { + charSequence330 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(330, charSequence330); + } else { + throw new RuntimeException(("Illegal union index for 'F330': "+ unionIndex330)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex331 = (decoder.readIndex()); + if (unionIndex331 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(331, null); + } else { + if (unionIndex331 == 1) { + Utf8 charSequence331; + Object oldString331 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(331); + if (oldString331 instanceof Utf8) { + charSequence331 = (decoder).readString(((Utf8) oldString331)); + } else { + charSequence331 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(331, charSequence331); + } else { + throw new RuntimeException(("Illegal union index for 'F331': "+ unionIndex331)); + } + } + int unionIndex332 = (decoder.readIndex()); + if (unionIndex332 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(332, null); + } else { + if (unionIndex332 == 1) { + Utf8 charSequence332; + Object oldString332 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(332); + if (oldString332 instanceof Utf8) { + charSequence332 = (decoder).readString(((Utf8) oldString332)); + } else { + charSequence332 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(332, charSequence332); + } else { + throw new RuntimeException(("Illegal union index for 'F332': "+ unionIndex332)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex333 = (decoder.readIndex()); + if (unionIndex333 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(333, null); + } else { + if (unionIndex333 == 1) { + Utf8 charSequence333; + Object oldString333 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(333); + if (oldString333 instanceof Utf8) { + charSequence333 = (decoder).readString(((Utf8) oldString333)); + } else { + charSequence333 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(333, charSequence333); + } else { + throw new RuntimeException(("Illegal union index for 'F333': "+ unionIndex333)); + } + } + int unionIndex334 = (decoder.readIndex()); + if (unionIndex334 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(334, null); + } else { + if (unionIndex334 == 1) { + Utf8 charSequence334; + Object oldString334 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(334); + if (oldString334 instanceof Utf8) { + charSequence334 = (decoder).readString(((Utf8) oldString334)); + } else { + charSequence334 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(334, charSequence334); + } else { + throw new RuntimeException(("Illegal union index for 'F334': "+ unionIndex334)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex335 = (decoder.readIndex()); + if (unionIndex335 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(335, null); + } else { + if (unionIndex335 == 1) { + Utf8 charSequence335; + Object oldString335 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(335); + if (oldString335 instanceof Utf8) { + charSequence335 = (decoder).readString(((Utf8) oldString335)); + } else { + charSequence335 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(335, charSequence335); + } else { + throw new RuntimeException(("Illegal union index for 'F335': "+ unionIndex335)); + } + } + int unionIndex336 = (decoder.readIndex()); + if (unionIndex336 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(336, null); + } else { + if (unionIndex336 == 1) { + Utf8 charSequence336; + Object oldString336 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(336); + if (oldString336 instanceof Utf8) { + charSequence336 = (decoder).readString(((Utf8) oldString336)); + } else { + charSequence336 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(336, charSequence336); + } else { + throw new RuntimeException(("Illegal union index for 'F336': "+ unionIndex336)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex337 = (decoder.readIndex()); + if (unionIndex337 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(337, null); + } else { + if (unionIndex337 == 1) { + Utf8 charSequence337; + Object oldString337 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(337); + if (oldString337 instanceof Utf8) { + charSequence337 = (decoder).readString(((Utf8) oldString337)); + } else { + charSequence337 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(337, charSequence337); + } else { + throw new RuntimeException(("Illegal union index for 'F337': "+ unionIndex337)); + } + } + int unionIndex338 = (decoder.readIndex()); + if (unionIndex338 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(338, null); + } else { + if (unionIndex338 == 1) { + Utf8 charSequence338; + Object oldString338 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(338); + if (oldString338 instanceof Utf8) { + charSequence338 = (decoder).readString(((Utf8) oldString338)); + } else { + charSequence338 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(338, charSequence338); + } else { + throw new RuntimeException(("Illegal union index for 'F338': "+ unionIndex338)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex339 = (decoder.readIndex()); + if (unionIndex339 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(339, null); + } else { + if (unionIndex339 == 1) { + Utf8 charSequence339; + Object oldString339 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(339); + if (oldString339 instanceof Utf8) { + charSequence339 = (decoder).readString(((Utf8) oldString339)); + } else { + charSequence339 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(339, charSequence339); + } else { + throw new RuntimeException(("Illegal union index for 'F339': "+ unionIndex339)); + } + } + int unionIndex340 = (decoder.readIndex()); + if (unionIndex340 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(340, null); + } else { + if (unionIndex340 == 1) { + Utf8 charSequence340; + Object oldString340 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(340); + if (oldString340 instanceof Utf8) { + charSequence340 = (decoder).readString(((Utf8) oldString340)); + } else { + charSequence340 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(340, charSequence340); + } else { + throw new RuntimeException(("Illegal union index for 'F340': "+ unionIndex340)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex341 = (decoder.readIndex()); + if (unionIndex341 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(341, null); + } else { + if (unionIndex341 == 1) { + Utf8 charSequence341; + Object oldString341 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(341); + if (oldString341 instanceof Utf8) { + charSequence341 = (decoder).readString(((Utf8) oldString341)); + } else { + charSequence341 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(341, charSequence341); + } else { + throw new RuntimeException(("Illegal union index for 'F341': "+ unionIndex341)); + } + } + int unionIndex342 = (decoder.readIndex()); + if (unionIndex342 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(342, null); + } else { + if (unionIndex342 == 1) { + Utf8 charSequence342; + Object oldString342 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(342); + if (oldString342 instanceof Utf8) { + charSequence342 = (decoder).readString(((Utf8) oldString342)); + } else { + charSequence342 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(342, charSequence342); + } else { + throw new RuntimeException(("Illegal union index for 'F342': "+ unionIndex342)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex343 = (decoder.readIndex()); + if (unionIndex343 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(343, null); + } else { + if (unionIndex343 == 1) { + Utf8 charSequence343; + Object oldString343 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(343); + if (oldString343 instanceof Utf8) { + charSequence343 = (decoder).readString(((Utf8) oldString343)); + } else { + charSequence343 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(343, charSequence343); + } else { + throw new RuntimeException(("Illegal union index for 'F343': "+ unionIndex343)); + } + } + int unionIndex344 = (decoder.readIndex()); + if (unionIndex344 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(344, null); + } else { + if (unionIndex344 == 1) { + Utf8 charSequence344; + Object oldString344 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(344); + if (oldString344 instanceof Utf8) { + charSequence344 = (decoder).readString(((Utf8) oldString344)); + } else { + charSequence344 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(344, charSequence344); + } else { + throw new RuntimeException(("Illegal union index for 'F344': "+ unionIndex344)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex345 = (decoder.readIndex()); + if (unionIndex345 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(345, null); + } else { + if (unionIndex345 == 1) { + Utf8 charSequence345; + Object oldString345 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(345); + if (oldString345 instanceof Utf8) { + charSequence345 = (decoder).readString(((Utf8) oldString345)); + } else { + charSequence345 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(345, charSequence345); + } else { + throw new RuntimeException(("Illegal union index for 'F345': "+ unionIndex345)); + } + } + int unionIndex346 = (decoder.readIndex()); + if (unionIndex346 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(346, null); + } else { + if (unionIndex346 == 1) { + Utf8 charSequence346; + Object oldString346 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(346); + if (oldString346 instanceof Utf8) { + charSequence346 = (decoder).readString(((Utf8) oldString346)); + } else { + charSequence346 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(346, charSequence346); + } else { + throw new RuntimeException(("Illegal union index for 'F346': "+ unionIndex346)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex347 = (decoder.readIndex()); + if (unionIndex347 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(347, null); + } else { + if (unionIndex347 == 1) { + Utf8 charSequence347; + Object oldString347 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(347); + if (oldString347 instanceof Utf8) { + charSequence347 = (decoder).readString(((Utf8) oldString347)); + } else { + charSequence347 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(347, charSequence347); + } else { + throw new RuntimeException(("Illegal union index for 'F347': "+ unionIndex347)); + } + } + int unionIndex348 = (decoder.readIndex()); + if (unionIndex348 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(348, null); + } else { + if (unionIndex348 == 1) { + Utf8 charSequence348; + Object oldString348 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(348); + if (oldString348 instanceof Utf8) { + charSequence348 = (decoder).readString(((Utf8) oldString348)); + } else { + charSequence348 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(348, charSequence348); + } else { + throw new RuntimeException(("Illegal union index for 'F348': "+ unionIndex348)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex349 = (decoder.readIndex()); + if (unionIndex349 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(349, null); + } else { + if (unionIndex349 == 1) { + Utf8 charSequence349; + Object oldString349 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(349); + if (oldString349 instanceof Utf8) { + charSequence349 = (decoder).readString(((Utf8) oldString349)); + } else { + charSequence349 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(349, charSequence349); + } else { + throw new RuntimeException(("Illegal union index for 'F349': "+ unionIndex349)); + } + } + int unionIndex350 = (decoder.readIndex()); + if (unionIndex350 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(350, null); + } else { + if (unionIndex350 == 1) { + Utf8 charSequence350; + Object oldString350 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(350); + if (oldString350 instanceof Utf8) { + charSequence350 = (decoder).readString(((Utf8) oldString350)); + } else { + charSequence350 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(350, charSequence350); + } else { + throw new RuntimeException(("Illegal union index for 'F350': "+ unionIndex350)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex351 = (decoder.readIndex()); + if (unionIndex351 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(351, null); + } else { + if (unionIndex351 == 1) { + Utf8 charSequence351; + Object oldString351 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(351); + if (oldString351 instanceof Utf8) { + charSequence351 = (decoder).readString(((Utf8) oldString351)); + } else { + charSequence351 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(351, charSequence351); + } else { + throw new RuntimeException(("Illegal union index for 'F351': "+ unionIndex351)); + } + } + int unionIndex352 = (decoder.readIndex()); + if (unionIndex352 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(352, null); + } else { + if (unionIndex352 == 1) { + Utf8 charSequence352; + Object oldString352 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(352); + if (oldString352 instanceof Utf8) { + charSequence352 = (decoder).readString(((Utf8) oldString352)); + } else { + charSequence352 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(352, charSequence352); + } else { + throw new RuntimeException(("Illegal union index for 'F352': "+ unionIndex352)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex353 = (decoder.readIndex()); + if (unionIndex353 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(353, null); + } else { + if (unionIndex353 == 1) { + Utf8 charSequence353; + Object oldString353 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(353); + if (oldString353 instanceof Utf8) { + charSequence353 = (decoder).readString(((Utf8) oldString353)); + } else { + charSequence353 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(353, charSequence353); + } else { + throw new RuntimeException(("Illegal union index for 'F353': "+ unionIndex353)); + } + } + int unionIndex354 = (decoder.readIndex()); + if (unionIndex354 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(354, null); + } else { + if (unionIndex354 == 1) { + Utf8 charSequence354; + Object oldString354 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(354); + if (oldString354 instanceof Utf8) { + charSequence354 = (decoder).readString(((Utf8) oldString354)); + } else { + charSequence354 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(354, charSequence354); + } else { + throw new RuntimeException(("Illegal union index for 'F354': "+ unionIndex354)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex355 = (decoder.readIndex()); + if (unionIndex355 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(355, null); + } else { + if (unionIndex355 == 1) { + Utf8 charSequence355; + Object oldString355 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(355); + if (oldString355 instanceof Utf8) { + charSequence355 = (decoder).readString(((Utf8) oldString355)); + } else { + charSequence355 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(355, charSequence355); + } else { + throw new RuntimeException(("Illegal union index for 'F355': "+ unionIndex355)); + } + } + int unionIndex356 = (decoder.readIndex()); + if (unionIndex356 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(356, null); + } else { + if (unionIndex356 == 1) { + Utf8 charSequence356; + Object oldString356 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(356); + if (oldString356 instanceof Utf8) { + charSequence356 = (decoder).readString(((Utf8) oldString356)); + } else { + charSequence356 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(356, charSequence356); + } else { + throw new RuntimeException(("Illegal union index for 'F356': "+ unionIndex356)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex357 = (decoder.readIndex()); + if (unionIndex357 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(357, null); + } else { + if (unionIndex357 == 1) { + Utf8 charSequence357; + Object oldString357 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(357); + if (oldString357 instanceof Utf8) { + charSequence357 = (decoder).readString(((Utf8) oldString357)); + } else { + charSequence357 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(357, charSequence357); + } else { + throw new RuntimeException(("Illegal union index for 'F357': "+ unionIndex357)); + } + } + int unionIndex358 = (decoder.readIndex()); + if (unionIndex358 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(358, null); + } else { + if (unionIndex358 == 1) { + Utf8 charSequence358; + Object oldString358 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(358); + if (oldString358 instanceof Utf8) { + charSequence358 = (decoder).readString(((Utf8) oldString358)); + } else { + charSequence358 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(358, charSequence358); + } else { + throw new RuntimeException(("Illegal union index for 'F358': "+ unionIndex358)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex359 = (decoder.readIndex()); + if (unionIndex359 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(359, null); + } else { + if (unionIndex359 == 1) { + Utf8 charSequence359; + Object oldString359 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(359); + if (oldString359 instanceof Utf8) { + charSequence359 = (decoder).readString(((Utf8) oldString359)); + } else { + charSequence359 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(359, charSequence359); + } else { + throw new RuntimeException(("Illegal union index for 'F359': "+ unionIndex359)); + } + } + int unionIndex360 = (decoder.readIndex()); + if (unionIndex360 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(360, null); + } else { + if (unionIndex360 == 1) { + Utf8 charSequence360; + Object oldString360 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(360); + if (oldString360 instanceof Utf8) { + charSequence360 = (decoder).readString(((Utf8) oldString360)); + } else { + charSequence360 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(360, charSequence360); + } else { + throw new RuntimeException(("Illegal union index for 'F360': "+ unionIndex360)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex361 = (decoder.readIndex()); + if (unionIndex361 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(361, null); + } else { + if (unionIndex361 == 1) { + Utf8 charSequence361; + Object oldString361 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(361); + if (oldString361 instanceof Utf8) { + charSequence361 = (decoder).readString(((Utf8) oldString361)); + } else { + charSequence361 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(361, charSequence361); + } else { + throw new RuntimeException(("Illegal union index for 'F361': "+ unionIndex361)); + } + } + int unionIndex362 = (decoder.readIndex()); + if (unionIndex362 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(362, null); + } else { + if (unionIndex362 == 1) { + Utf8 charSequence362; + Object oldString362 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(362); + if (oldString362 instanceof Utf8) { + charSequence362 = (decoder).readString(((Utf8) oldString362)); + } else { + charSequence362 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(362, charSequence362); + } else { + throw new RuntimeException(("Illegal union index for 'F362': "+ unionIndex362)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex363 = (decoder.readIndex()); + if (unionIndex363 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(363, null); + } else { + if (unionIndex363 == 1) { + Utf8 charSequence363; + Object oldString363 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(363); + if (oldString363 instanceof Utf8) { + charSequence363 = (decoder).readString(((Utf8) oldString363)); + } else { + charSequence363 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(363, charSequence363); + } else { + throw new RuntimeException(("Illegal union index for 'F363': "+ unionIndex363)); + } + } + int unionIndex364 = (decoder.readIndex()); + if (unionIndex364 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(364, null); + } else { + if (unionIndex364 == 1) { + Utf8 charSequence364; + Object oldString364 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(364); + if (oldString364 instanceof Utf8) { + charSequence364 = (decoder).readString(((Utf8) oldString364)); + } else { + charSequence364 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(364, charSequence364); + } else { + throw new RuntimeException(("Illegal union index for 'F364': "+ unionIndex364)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex365 = (decoder.readIndex()); + if (unionIndex365 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(365, null); + } else { + if (unionIndex365 == 1) { + Utf8 charSequence365; + Object oldString365 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(365); + if (oldString365 instanceof Utf8) { + charSequence365 = (decoder).readString(((Utf8) oldString365)); + } else { + charSequence365 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(365, charSequence365); + } else { + throw new RuntimeException(("Illegal union index for 'F365': "+ unionIndex365)); + } + } + int unionIndex366 = (decoder.readIndex()); + if (unionIndex366 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(366, null); + } else { + if (unionIndex366 == 1) { + Utf8 charSequence366; + Object oldString366 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(366); + if (oldString366 instanceof Utf8) { + charSequence366 = (decoder).readString(((Utf8) oldString366)); + } else { + charSequence366 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(366, charSequence366); + } else { + throw new RuntimeException(("Illegal union index for 'F366': "+ unionIndex366)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex367 = (decoder.readIndex()); + if (unionIndex367 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(367, null); + } else { + if (unionIndex367 == 1) { + Utf8 charSequence367; + Object oldString367 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(367); + if (oldString367 instanceof Utf8) { + charSequence367 = (decoder).readString(((Utf8) oldString367)); + } else { + charSequence367 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(367, charSequence367); + } else { + throw new RuntimeException(("Illegal union index for 'F367': "+ unionIndex367)); + } + } + int unionIndex368 = (decoder.readIndex()); + if (unionIndex368 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(368, null); + } else { + if (unionIndex368 == 1) { + Utf8 charSequence368; + Object oldString368 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(368); + if (oldString368 instanceof Utf8) { + charSequence368 = (decoder).readString(((Utf8) oldString368)); + } else { + charSequence368 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(368, charSequence368); + } else { + throw new RuntimeException(("Illegal union index for 'F368': "+ unionIndex368)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex369 = (decoder.readIndex()); + if (unionIndex369 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(369, null); + } else { + if (unionIndex369 == 1) { + Utf8 charSequence369; + Object oldString369 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(369); + if (oldString369 instanceof Utf8) { + charSequence369 = (decoder).readString(((Utf8) oldString369)); + } else { + charSequence369 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(369, charSequence369); + } else { + throw new RuntimeException(("Illegal union index for 'F369': "+ unionIndex369)); + } + } + int unionIndex370 = (decoder.readIndex()); + if (unionIndex370 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(370, null); + } else { + if (unionIndex370 == 1) { + Utf8 charSequence370; + Object oldString370 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(370); + if (oldString370 instanceof Utf8) { + charSequence370 = (decoder).readString(((Utf8) oldString370)); + } else { + charSequence370 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(370, charSequence370); + } else { + throw new RuntimeException(("Illegal union index for 'F370': "+ unionIndex370)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex371 = (decoder.readIndex()); + if (unionIndex371 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(371, null); + } else { + if (unionIndex371 == 1) { + Utf8 charSequence371; + Object oldString371 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(371); + if (oldString371 instanceof Utf8) { + charSequence371 = (decoder).readString(((Utf8) oldString371)); + } else { + charSequence371 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(371, charSequence371); + } else { + throw new RuntimeException(("Illegal union index for 'F371': "+ unionIndex371)); + } + } + int unionIndex372 = (decoder.readIndex()); + if (unionIndex372 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(372, null); + } else { + if (unionIndex372 == 1) { + Utf8 charSequence372; + Object oldString372 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(372); + if (oldString372 instanceof Utf8) { + charSequence372 = (decoder).readString(((Utf8) oldString372)); + } else { + charSequence372 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(372, charSequence372); + } else { + throw new RuntimeException(("Illegal union index for 'F372': "+ unionIndex372)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex373 = (decoder.readIndex()); + if (unionIndex373 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(373, null); + } else { + if (unionIndex373 == 1) { + Utf8 charSequence373; + Object oldString373 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(373); + if (oldString373 instanceof Utf8) { + charSequence373 = (decoder).readString(((Utf8) oldString373)); + } else { + charSequence373 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(373, charSequence373); + } else { + throw new RuntimeException(("Illegal union index for 'F373': "+ unionIndex373)); + } + } + int unionIndex374 = (decoder.readIndex()); + if (unionIndex374 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(374, null); + } else { + if (unionIndex374 == 1) { + Utf8 charSequence374; + Object oldString374 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(374); + if (oldString374 instanceof Utf8) { + charSequence374 = (decoder).readString(((Utf8) oldString374)); + } else { + charSequence374 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(374, charSequence374); + } else { + throw new RuntimeException(("Illegal union index for 'F374': "+ unionIndex374)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex375 = (decoder.readIndex()); + if (unionIndex375 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(375, null); + } else { + if (unionIndex375 == 1) { + Utf8 charSequence375; + Object oldString375 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(375); + if (oldString375 instanceof Utf8) { + charSequence375 = (decoder).readString(((Utf8) oldString375)); + } else { + charSequence375 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(375, charSequence375); + } else { + throw new RuntimeException(("Illegal union index for 'F375': "+ unionIndex375)); + } + } + int unionIndex376 = (decoder.readIndex()); + if (unionIndex376 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(376, null); + } else { + if (unionIndex376 == 1) { + Utf8 charSequence376; + Object oldString376 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(376); + if (oldString376 instanceof Utf8) { + charSequence376 = (decoder).readString(((Utf8) oldString376)); + } else { + charSequence376 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(376, charSequence376); + } else { + throw new RuntimeException(("Illegal union index for 'F376': "+ unionIndex376)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex377 = (decoder.readIndex()); + if (unionIndex377 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(377, null); + } else { + if (unionIndex377 == 1) { + Utf8 charSequence377; + Object oldString377 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(377); + if (oldString377 instanceof Utf8) { + charSequence377 = (decoder).readString(((Utf8) oldString377)); + } else { + charSequence377 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(377, charSequence377); + } else { + throw new RuntimeException(("Illegal union index for 'F377': "+ unionIndex377)); + } + } + int unionIndex378 = (decoder.readIndex()); + if (unionIndex378 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(378, null); + } else { + if (unionIndex378 == 1) { + Utf8 charSequence378; + Object oldString378 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(378); + if (oldString378 instanceof Utf8) { + charSequence378 = (decoder).readString(((Utf8) oldString378)); + } else { + charSequence378 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(378, charSequence378); + } else { + throw new RuntimeException(("Illegal union index for 'F378': "+ unionIndex378)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex379 = (decoder.readIndex()); + if (unionIndex379 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(379, null); + } else { + if (unionIndex379 == 1) { + Utf8 charSequence379; + Object oldString379 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(379); + if (oldString379 instanceof Utf8) { + charSequence379 = (decoder).readString(((Utf8) oldString379)); + } else { + charSequence379 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(379, charSequence379); + } else { + throw new RuntimeException(("Illegal union index for 'F379': "+ unionIndex379)); + } + } + int unionIndex380 = (decoder.readIndex()); + if (unionIndex380 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(380, null); + } else { + if (unionIndex380 == 1) { + Utf8 charSequence380; + Object oldString380 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(380); + if (oldString380 instanceof Utf8) { + charSequence380 = (decoder).readString(((Utf8) oldString380)); + } else { + charSequence380 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(380, charSequence380); + } else { + throw new RuntimeException(("Illegal union index for 'F380': "+ unionIndex380)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex381 = (decoder.readIndex()); + if (unionIndex381 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(381, null); + } else { + if (unionIndex381 == 1) { + Utf8 charSequence381; + Object oldString381 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(381); + if (oldString381 instanceof Utf8) { + charSequence381 = (decoder).readString(((Utf8) oldString381)); + } else { + charSequence381 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(381, charSequence381); + } else { + throw new RuntimeException(("Illegal union index for 'F381': "+ unionIndex381)); + } + } + int unionIndex382 = (decoder.readIndex()); + if (unionIndex382 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(382, null); + } else { + if (unionIndex382 == 1) { + Utf8 charSequence382; + Object oldString382 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(382); + if (oldString382 instanceof Utf8) { + charSequence382 = (decoder).readString(((Utf8) oldString382)); + } else { + charSequence382 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(382, charSequence382); + } else { + throw new RuntimeException(("Illegal union index for 'F382': "+ unionIndex382)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex383 = (decoder.readIndex()); + if (unionIndex383 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(383, null); + } else { + if (unionIndex383 == 1) { + Utf8 charSequence383; + Object oldString383 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(383); + if (oldString383 instanceof Utf8) { + charSequence383 = (decoder).readString(((Utf8) oldString383)); + } else { + charSequence383 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(383, charSequence383); + } else { + throw new RuntimeException(("Illegal union index for 'F383': "+ unionIndex383)); + } + } + int unionIndex384 = (decoder.readIndex()); + if (unionIndex384 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(384, null); + } else { + if (unionIndex384 == 1) { + Utf8 charSequence384; + Object oldString384 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(384); + if (oldString384 instanceof Utf8) { + charSequence384 = (decoder).readString(((Utf8) oldString384)); + } else { + charSequence384 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(384, charSequence384); + } else { + throw new RuntimeException(("Illegal union index for 'F384': "+ unionIndex384)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex385 = (decoder.readIndex()); + if (unionIndex385 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(385, null); + } else { + if (unionIndex385 == 1) { + Utf8 charSequence385; + Object oldString385 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(385); + if (oldString385 instanceof Utf8) { + charSequence385 = (decoder).readString(((Utf8) oldString385)); + } else { + charSequence385 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(385, charSequence385); + } else { + throw new RuntimeException(("Illegal union index for 'F385': "+ unionIndex385)); + } + } + int unionIndex386 = (decoder.readIndex()); + if (unionIndex386 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(386, null); + } else { + if (unionIndex386 == 1) { + Utf8 charSequence386; + Object oldString386 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(386); + if (oldString386 instanceof Utf8) { + charSequence386 = (decoder).readString(((Utf8) oldString386)); + } else { + charSequence386 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(386, charSequence386); + } else { + throw new RuntimeException(("Illegal union index for 'F386': "+ unionIndex386)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex387 = (decoder.readIndex()); + if (unionIndex387 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(387, null); + } else { + if (unionIndex387 == 1) { + Utf8 charSequence387; + Object oldString387 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(387); + if (oldString387 instanceof Utf8) { + charSequence387 = (decoder).readString(((Utf8) oldString387)); + } else { + charSequence387 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(387, charSequence387); + } else { + throw new RuntimeException(("Illegal union index for 'F387': "+ unionIndex387)); + } + } + int unionIndex388 = (decoder.readIndex()); + if (unionIndex388 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(388, null); + } else { + if (unionIndex388 == 1) { + Utf8 charSequence388; + Object oldString388 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(388); + if (oldString388 instanceof Utf8) { + charSequence388 = (decoder).readString(((Utf8) oldString388)); + } else { + charSequence388 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(388, charSequence388); + } else { + throw new RuntimeException(("Illegal union index for 'F388': "+ unionIndex388)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex389 = (decoder.readIndex()); + if (unionIndex389 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(389, null); + } else { + if (unionIndex389 == 1) { + Utf8 charSequence389; + Object oldString389 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(389); + if (oldString389 instanceof Utf8) { + charSequence389 = (decoder).readString(((Utf8) oldString389)); + } else { + charSequence389 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(389, charSequence389); + } else { + throw new RuntimeException(("Illegal union index for 'F389': "+ unionIndex389)); + } + } + int unionIndex390 = (decoder.readIndex()); + if (unionIndex390 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(390, null); + } else { + if (unionIndex390 == 1) { + Utf8 charSequence390; + Object oldString390 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(390); + if (oldString390 instanceof Utf8) { + charSequence390 = (decoder).readString(((Utf8) oldString390)); + } else { + charSequence390 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(390, charSequence390); + } else { + throw new RuntimeException(("Illegal union index for 'F390': "+ unionIndex390)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex391 = (decoder.readIndex()); + if (unionIndex391 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(391, null); + } else { + if (unionIndex391 == 1) { + Utf8 charSequence391; + Object oldString391 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(391); + if (oldString391 instanceof Utf8) { + charSequence391 = (decoder).readString(((Utf8) oldString391)); + } else { + charSequence391 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(391, charSequence391); + } else { + throw new RuntimeException(("Illegal union index for 'F391': "+ unionIndex391)); + } + } + int unionIndex392 = (decoder.readIndex()); + if (unionIndex392 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(392, null); + } else { + if (unionIndex392 == 1) { + Utf8 charSequence392; + Object oldString392 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(392); + if (oldString392 instanceof Utf8) { + charSequence392 = (decoder).readString(((Utf8) oldString392)); + } else { + charSequence392 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(392, charSequence392); + } else { + throw new RuntimeException(("Illegal union index for 'F392': "+ unionIndex392)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex393 = (decoder.readIndex()); + if (unionIndex393 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(393, null); + } else { + if (unionIndex393 == 1) { + Utf8 charSequence393; + Object oldString393 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(393); + if (oldString393 instanceof Utf8) { + charSequence393 = (decoder).readString(((Utf8) oldString393)); + } else { + charSequence393 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(393, charSequence393); + } else { + throw new RuntimeException(("Illegal union index for 'F393': "+ unionIndex393)); + } + } + int unionIndex394 = (decoder.readIndex()); + if (unionIndex394 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(394, null); + } else { + if (unionIndex394 == 1) { + Utf8 charSequence394; + Object oldString394 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(394); + if (oldString394 instanceof Utf8) { + charSequence394 = (decoder).readString(((Utf8) oldString394)); + } else { + charSequence394 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(394, charSequence394); + } else { + throw new RuntimeException(("Illegal union index for 'F394': "+ unionIndex394)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex395 = (decoder.readIndex()); + if (unionIndex395 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(395, null); + } else { + if (unionIndex395 == 1) { + Utf8 charSequence395; + Object oldString395 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(395); + if (oldString395 instanceof Utf8) { + charSequence395 = (decoder).readString(((Utf8) oldString395)); + } else { + charSequence395 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(395, charSequence395); + } else { + throw new RuntimeException(("Illegal union index for 'F395': "+ unionIndex395)); + } + } + int unionIndex396 = (decoder.readIndex()); + if (unionIndex396 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(396, null); + } else { + if (unionIndex396 == 1) { + Utf8 charSequence396; + Object oldString396 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(396); + if (oldString396 instanceof Utf8) { + charSequence396 = (decoder).readString(((Utf8) oldString396)); + } else { + charSequence396 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(396, charSequence396); + } else { + throw new RuntimeException(("Illegal union index for 'F396': "+ unionIndex396)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex397 = (decoder.readIndex()); + if (unionIndex397 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(397, null); + } else { + if (unionIndex397 == 1) { + Utf8 charSequence397; + Object oldString397 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(397); + if (oldString397 instanceof Utf8) { + charSequence397 = (decoder).readString(((Utf8) oldString397)); + } else { + charSequence397 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(397, charSequence397); + } else { + throw new RuntimeException(("Illegal union index for 'F397': "+ unionIndex397)); + } + } + int unionIndex398 = (decoder.readIndex()); + if (unionIndex398 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(398, null); + } else { + if (unionIndex398 == 1) { + Utf8 charSequence398; + Object oldString398 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(398); + if (oldString398 instanceof Utf8) { + charSequence398 = (decoder).readString(((Utf8) oldString398)); + } else { + charSequence398 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(398, charSequence398); + } else { + throw new RuntimeException(("Illegal union index for 'F398': "+ unionIndex398)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex399 = (decoder.readIndex()); + if (unionIndex399 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(399, null); + } else { + if (unionIndex399 == 1) { + Utf8 charSequence399; + Object oldString399 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(399); + if (oldString399 instanceof Utf8) { + charSequence399 = (decoder).readString(((Utf8) oldString399)); + } else { + charSequence399 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(399, charSequence399); + } else { + throw new RuntimeException(("Illegal union index for 'F399': "+ unionIndex399)); + } + } + int unionIndex400 = (decoder.readIndex()); + if (unionIndex400 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(400, null); + } else { + if (unionIndex400 == 1) { + Utf8 charSequence400; + Object oldString400 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(400); + if (oldString400 instanceof Utf8) { + charSequence400 = (decoder).readString(((Utf8) oldString400)); + } else { + charSequence400 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(400, charSequence400); + } else { + throw new RuntimeException(("Illegal union index for 'F400': "+ unionIndex400)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex401 = (decoder.readIndex()); + if (unionIndex401 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(401, null); + } else { + if (unionIndex401 == 1) { + Utf8 charSequence401; + Object oldString401 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(401); + if (oldString401 instanceof Utf8) { + charSequence401 = (decoder).readString(((Utf8) oldString401)); + } else { + charSequence401 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(401, charSequence401); + } else { + throw new RuntimeException(("Illegal union index for 'F401': "+ unionIndex401)); + } + } + int unionIndex402 = (decoder.readIndex()); + if (unionIndex402 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(402, null); + } else { + if (unionIndex402 == 1) { + Utf8 charSequence402; + Object oldString402 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(402); + if (oldString402 instanceof Utf8) { + charSequence402 = (decoder).readString(((Utf8) oldString402)); + } else { + charSequence402 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(402, charSequence402); + } else { + throw new RuntimeException(("Illegal union index for 'F402': "+ unionIndex402)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex403 = (decoder.readIndex()); + if (unionIndex403 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(403, null); + } else { + if (unionIndex403 == 1) { + Utf8 charSequence403; + Object oldString403 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(403); + if (oldString403 instanceof Utf8) { + charSequence403 = (decoder).readString(((Utf8) oldString403)); + } else { + charSequence403 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(403, charSequence403); + } else { + throw new RuntimeException(("Illegal union index for 'F403': "+ unionIndex403)); + } + } + int unionIndex404 = (decoder.readIndex()); + if (unionIndex404 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(404, null); + } else { + if (unionIndex404 == 1) { + Utf8 charSequence404; + Object oldString404 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(404); + if (oldString404 instanceof Utf8) { + charSequence404 = (decoder).readString(((Utf8) oldString404)); + } else { + charSequence404 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(404, charSequence404); + } else { + throw new RuntimeException(("Illegal union index for 'F404': "+ unionIndex404)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex405 = (decoder.readIndex()); + if (unionIndex405 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(405, null); + } else { + if (unionIndex405 == 1) { + Utf8 charSequence405; + Object oldString405 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(405); + if (oldString405 instanceof Utf8) { + charSequence405 = (decoder).readString(((Utf8) oldString405)); + } else { + charSequence405 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(405, charSequence405); + } else { + throw new RuntimeException(("Illegal union index for 'F405': "+ unionIndex405)); + } + } + int unionIndex406 = (decoder.readIndex()); + if (unionIndex406 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(406, null); + } else { + if (unionIndex406 == 1) { + Utf8 charSequence406; + Object oldString406 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(406); + if (oldString406 instanceof Utf8) { + charSequence406 = (decoder).readString(((Utf8) oldString406)); + } else { + charSequence406 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(406, charSequence406); + } else { + throw new RuntimeException(("Illegal union index for 'F406': "+ unionIndex406)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex407 = (decoder.readIndex()); + if (unionIndex407 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(407, null); + } else { + if (unionIndex407 == 1) { + Utf8 charSequence407; + Object oldString407 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(407); + if (oldString407 instanceof Utf8) { + charSequence407 = (decoder).readString(((Utf8) oldString407)); + } else { + charSequence407 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(407, charSequence407); + } else { + throw new RuntimeException(("Illegal union index for 'F407': "+ unionIndex407)); + } + } + int unionIndex408 = (decoder.readIndex()); + if (unionIndex408 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(408, null); + } else { + if (unionIndex408 == 1) { + Utf8 charSequence408; + Object oldString408 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(408); + if (oldString408 instanceof Utf8) { + charSequence408 = (decoder).readString(((Utf8) oldString408)); + } else { + charSequence408 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(408, charSequence408); + } else { + throw new RuntimeException(("Illegal union index for 'F408': "+ unionIndex408)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex409 = (decoder.readIndex()); + if (unionIndex409 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(409, null); + } else { + if (unionIndex409 == 1) { + Utf8 charSequence409; + Object oldString409 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(409); + if (oldString409 instanceof Utf8) { + charSequence409 = (decoder).readString(((Utf8) oldString409)); + } else { + charSequence409 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(409, charSequence409); + } else { + throw new RuntimeException(("Illegal union index for 'F409': "+ unionIndex409)); + } + } + int unionIndex410 = (decoder.readIndex()); + if (unionIndex410 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(410, null); + } else { + if (unionIndex410 == 1) { + Utf8 charSequence410; + Object oldString410 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(410); + if (oldString410 instanceof Utf8) { + charSequence410 = (decoder).readString(((Utf8) oldString410)); + } else { + charSequence410 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(410, charSequence410); + } else { + throw new RuntimeException(("Illegal union index for 'F410': "+ unionIndex410)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex411 = (decoder.readIndex()); + if (unionIndex411 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(411, null); + } else { + if (unionIndex411 == 1) { + Utf8 charSequence411; + Object oldString411 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(411); + if (oldString411 instanceof Utf8) { + charSequence411 = (decoder).readString(((Utf8) oldString411)); + } else { + charSequence411 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(411, charSequence411); + } else { + throw new RuntimeException(("Illegal union index for 'F411': "+ unionIndex411)); + } + } + int unionIndex412 = (decoder.readIndex()); + if (unionIndex412 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(412, null); + } else { + if (unionIndex412 == 1) { + Utf8 charSequence412; + Object oldString412 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(412); + if (oldString412 instanceof Utf8) { + charSequence412 = (decoder).readString(((Utf8) oldString412)); + } else { + charSequence412 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(412, charSequence412); + } else { + throw new RuntimeException(("Illegal union index for 'F412': "+ unionIndex412)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex413 = (decoder.readIndex()); + if (unionIndex413 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(413, null); + } else { + if (unionIndex413 == 1) { + Utf8 charSequence413; + Object oldString413 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(413); + if (oldString413 instanceof Utf8) { + charSequence413 = (decoder).readString(((Utf8) oldString413)); + } else { + charSequence413 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(413, charSequence413); + } else { + throw new RuntimeException(("Illegal union index for 'F413': "+ unionIndex413)); + } + } + int unionIndex414 = (decoder.readIndex()); + if (unionIndex414 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(414, null); + } else { + if (unionIndex414 == 1) { + Utf8 charSequence414; + Object oldString414 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(414); + if (oldString414 instanceof Utf8) { + charSequence414 = (decoder).readString(((Utf8) oldString414)); + } else { + charSequence414 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(414, charSequence414); + } else { + throw new RuntimeException(("Illegal union index for 'F414': "+ unionIndex414)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex415 = (decoder.readIndex()); + if (unionIndex415 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(415, null); + } else { + if (unionIndex415 == 1) { + Utf8 charSequence415; + Object oldString415 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(415); + if (oldString415 instanceof Utf8) { + charSequence415 = (decoder).readString(((Utf8) oldString415)); + } else { + charSequence415 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(415, charSequence415); + } else { + throw new RuntimeException(("Illegal union index for 'F415': "+ unionIndex415)); + } + } + int unionIndex416 = (decoder.readIndex()); + if (unionIndex416 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(416, null); + } else { + if (unionIndex416 == 1) { + Utf8 charSequence416; + Object oldString416 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(416); + if (oldString416 instanceof Utf8) { + charSequence416 = (decoder).readString(((Utf8) oldString416)); + } else { + charSequence416 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(416, charSequence416); + } else { + throw new RuntimeException(("Illegal union index for 'F416': "+ unionIndex416)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex417 = (decoder.readIndex()); + if (unionIndex417 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(417, null); + } else { + if (unionIndex417 == 1) { + Utf8 charSequence417; + Object oldString417 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(417); + if (oldString417 instanceof Utf8) { + charSequence417 = (decoder).readString(((Utf8) oldString417)); + } else { + charSequence417 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(417, charSequence417); + } else { + throw new RuntimeException(("Illegal union index for 'F417': "+ unionIndex417)); + } + } + int unionIndex418 = (decoder.readIndex()); + if (unionIndex418 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(418, null); + } else { + if (unionIndex418 == 1) { + Utf8 charSequence418; + Object oldString418 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(418); + if (oldString418 instanceof Utf8) { + charSequence418 = (decoder).readString(((Utf8) oldString418)); + } else { + charSequence418 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(418, charSequence418); + } else { + throw new RuntimeException(("Illegal union index for 'F418': "+ unionIndex418)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex419 = (decoder.readIndex()); + if (unionIndex419 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(419, null); + } else { + if (unionIndex419 == 1) { + Utf8 charSequence419; + Object oldString419 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(419); + if (oldString419 instanceof Utf8) { + charSequence419 = (decoder).readString(((Utf8) oldString419)); + } else { + charSequence419 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(419, charSequence419); + } else { + throw new RuntimeException(("Illegal union index for 'F419': "+ unionIndex419)); + } + } + int unionIndex420 = (decoder.readIndex()); + if (unionIndex420 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(420, null); + } else { + if (unionIndex420 == 1) { + Utf8 charSequence420; + Object oldString420 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(420); + if (oldString420 instanceof Utf8) { + charSequence420 = (decoder).readString(((Utf8) oldString420)); + } else { + charSequence420 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(420, charSequence420); + } else { + throw new RuntimeException(("Illegal union index for 'F420': "+ unionIndex420)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex421 = (decoder.readIndex()); + if (unionIndex421 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(421, null); + } else { + if (unionIndex421 == 1) { + Utf8 charSequence421; + Object oldString421 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(421); + if (oldString421 instanceof Utf8) { + charSequence421 = (decoder).readString(((Utf8) oldString421)); + } else { + charSequence421 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(421, charSequence421); + } else { + throw new RuntimeException(("Illegal union index for 'F421': "+ unionIndex421)); + } + } + int unionIndex422 = (decoder.readIndex()); + if (unionIndex422 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(422, null); + } else { + if (unionIndex422 == 1) { + Utf8 charSequence422; + Object oldString422 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(422); + if (oldString422 instanceof Utf8) { + charSequence422 = (decoder).readString(((Utf8) oldString422)); + } else { + charSequence422 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(422, charSequence422); + } else { + throw new RuntimeException(("Illegal union index for 'F422': "+ unionIndex422)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex423 = (decoder.readIndex()); + if (unionIndex423 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(423, null); + } else { + if (unionIndex423 == 1) { + Utf8 charSequence423; + Object oldString423 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(423); + if (oldString423 instanceof Utf8) { + charSequence423 = (decoder).readString(((Utf8) oldString423)); + } else { + charSequence423 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(423, charSequence423); + } else { + throw new RuntimeException(("Illegal union index for 'F423': "+ unionIndex423)); + } + } + int unionIndex424 = (decoder.readIndex()); + if (unionIndex424 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(424, null); + } else { + if (unionIndex424 == 1) { + Utf8 charSequence424; + Object oldString424 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(424); + if (oldString424 instanceof Utf8) { + charSequence424 = (decoder).readString(((Utf8) oldString424)); + } else { + charSequence424 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(424, charSequence424); + } else { + throw new RuntimeException(("Illegal union index for 'F424': "+ unionIndex424)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex425 = (decoder.readIndex()); + if (unionIndex425 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(425, null); + } else { + if (unionIndex425 == 1) { + Utf8 charSequence425; + Object oldString425 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(425); + if (oldString425 instanceof Utf8) { + charSequence425 = (decoder).readString(((Utf8) oldString425)); + } else { + charSequence425 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(425, charSequence425); + } else { + throw new RuntimeException(("Illegal union index for 'F425': "+ unionIndex425)); + } + } + int unionIndex426 = (decoder.readIndex()); + if (unionIndex426 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(426, null); + } else { + if (unionIndex426 == 1) { + Utf8 charSequence426; + Object oldString426 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(426); + if (oldString426 instanceof Utf8) { + charSequence426 = (decoder).readString(((Utf8) oldString426)); + } else { + charSequence426 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(426, charSequence426); + } else { + throw new RuntimeException(("Illegal union index for 'F426': "+ unionIndex426)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex427 = (decoder.readIndex()); + if (unionIndex427 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(427, null); + } else { + if (unionIndex427 == 1) { + Utf8 charSequence427; + Object oldString427 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(427); + if (oldString427 instanceof Utf8) { + charSequence427 = (decoder).readString(((Utf8) oldString427)); + } else { + charSequence427 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(427, charSequence427); + } else { + throw new RuntimeException(("Illegal union index for 'F427': "+ unionIndex427)); + } + } + int unionIndex428 = (decoder.readIndex()); + if (unionIndex428 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(428, null); + } else { + if (unionIndex428 == 1) { + Utf8 charSequence428; + Object oldString428 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(428); + if (oldString428 instanceof Utf8) { + charSequence428 = (decoder).readString(((Utf8) oldString428)); + } else { + charSequence428 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(428, charSequence428); + } else { + throw new RuntimeException(("Illegal union index for 'F428': "+ unionIndex428)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex429 = (decoder.readIndex()); + if (unionIndex429 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(429, null); + } else { + if (unionIndex429 == 1) { + Utf8 charSequence429; + Object oldString429 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(429); + if (oldString429 instanceof Utf8) { + charSequence429 = (decoder).readString(((Utf8) oldString429)); + } else { + charSequence429 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(429, charSequence429); + } else { + throw new RuntimeException(("Illegal union index for 'F429': "+ unionIndex429)); + } + } + int unionIndex430 = (decoder.readIndex()); + if (unionIndex430 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(430, null); + } else { + if (unionIndex430 == 1) { + Utf8 charSequence430; + Object oldString430 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(430); + if (oldString430 instanceof Utf8) { + charSequence430 = (decoder).readString(((Utf8) oldString430)); + } else { + charSequence430 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(430, charSequence430); + } else { + throw new RuntimeException(("Illegal union index for 'F430': "+ unionIndex430)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex431 = (decoder.readIndex()); + if (unionIndex431 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(431, null); + } else { + if (unionIndex431 == 1) { + Utf8 charSequence431; + Object oldString431 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(431); + if (oldString431 instanceof Utf8) { + charSequence431 = (decoder).readString(((Utf8) oldString431)); + } else { + charSequence431 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(431, charSequence431); + } else { + throw new RuntimeException(("Illegal union index for 'F431': "+ unionIndex431)); + } + } + int unionIndex432 = (decoder.readIndex()); + if (unionIndex432 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(432, null); + } else { + if (unionIndex432 == 1) { + Utf8 charSequence432; + Object oldString432 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(432); + if (oldString432 instanceof Utf8) { + charSequence432 = (decoder).readString(((Utf8) oldString432)); + } else { + charSequence432 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(432, charSequence432); + } else { + throw new RuntimeException(("Illegal union index for 'F432': "+ unionIndex432)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex433 = (decoder.readIndex()); + if (unionIndex433 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(433, null); + } else { + if (unionIndex433 == 1) { + Utf8 charSequence433; + Object oldString433 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(433); + if (oldString433 instanceof Utf8) { + charSequence433 = (decoder).readString(((Utf8) oldString433)); + } else { + charSequence433 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(433, charSequence433); + } else { + throw new RuntimeException(("Illegal union index for 'F433': "+ unionIndex433)); + } + } + int unionIndex434 = (decoder.readIndex()); + if (unionIndex434 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(434, null); + } else { + if (unionIndex434 == 1) { + Utf8 charSequence434; + Object oldString434 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(434); + if (oldString434 instanceof Utf8) { + charSequence434 = (decoder).readString(((Utf8) oldString434)); + } else { + charSequence434 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(434, charSequence434); + } else { + throw new RuntimeException(("Illegal union index for 'F434': "+ unionIndex434)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex435 = (decoder.readIndex()); + if (unionIndex435 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(435, null); + } else { + if (unionIndex435 == 1) { + Utf8 charSequence435; + Object oldString435 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(435); + if (oldString435 instanceof Utf8) { + charSequence435 = (decoder).readString(((Utf8) oldString435)); + } else { + charSequence435 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(435, charSequence435); + } else { + throw new RuntimeException(("Illegal union index for 'F435': "+ unionIndex435)); + } + } + int unionIndex436 = (decoder.readIndex()); + if (unionIndex436 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(436, null); + } else { + if (unionIndex436 == 1) { + Utf8 charSequence436; + Object oldString436 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(436); + if (oldString436 instanceof Utf8) { + charSequence436 = (decoder).readString(((Utf8) oldString436)); + } else { + charSequence436 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(436, charSequence436); + } else { + throw new RuntimeException(("Illegal union index for 'F436': "+ unionIndex436)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex437 = (decoder.readIndex()); + if (unionIndex437 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(437, null); + } else { + if (unionIndex437 == 1) { + Utf8 charSequence437; + Object oldString437 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(437); + if (oldString437 instanceof Utf8) { + charSequence437 = (decoder).readString(((Utf8) oldString437)); + } else { + charSequence437 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(437, charSequence437); + } else { + throw new RuntimeException(("Illegal union index for 'F437': "+ unionIndex437)); + } + } + int unionIndex438 = (decoder.readIndex()); + if (unionIndex438 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(438, null); + } else { + if (unionIndex438 == 1) { + Utf8 charSequence438; + Object oldString438 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(438); + if (oldString438 instanceof Utf8) { + charSequence438 = (decoder).readString(((Utf8) oldString438)); + } else { + charSequence438 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(438, charSequence438); + } else { + throw new RuntimeException(("Illegal union index for 'F438': "+ unionIndex438)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex439 = (decoder.readIndex()); + if (unionIndex439 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(439, null); + } else { + if (unionIndex439 == 1) { + Utf8 charSequence439; + Object oldString439 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(439); + if (oldString439 instanceof Utf8) { + charSequence439 = (decoder).readString(((Utf8) oldString439)); + } else { + charSequence439 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(439, charSequence439); + } else { + throw new RuntimeException(("Illegal union index for 'F439': "+ unionIndex439)); + } + } + int unionIndex440 = (decoder.readIndex()); + if (unionIndex440 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(440, null); + } else { + if (unionIndex440 == 1) { + Utf8 charSequence440; + Object oldString440 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(440); + if (oldString440 instanceof Utf8) { + charSequence440 = (decoder).readString(((Utf8) oldString440)); + } else { + charSequence440 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(440, charSequence440); + } else { + throw new RuntimeException(("Illegal union index for 'F440': "+ unionIndex440)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex441 = (decoder.readIndex()); + if (unionIndex441 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(441, null); + } else { + if (unionIndex441 == 1) { + Utf8 charSequence441; + Object oldString441 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(441); + if (oldString441 instanceof Utf8) { + charSequence441 = (decoder).readString(((Utf8) oldString441)); + } else { + charSequence441 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(441, charSequence441); + } else { + throw new RuntimeException(("Illegal union index for 'F441': "+ unionIndex441)); + } + } + int unionIndex442 = (decoder.readIndex()); + if (unionIndex442 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(442, null); + } else { + if (unionIndex442 == 1) { + Utf8 charSequence442; + Object oldString442 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(442); + if (oldString442 instanceof Utf8) { + charSequence442 = (decoder).readString(((Utf8) oldString442)); + } else { + charSequence442 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(442, charSequence442); + } else { + throw new RuntimeException(("Illegal union index for 'F442': "+ unionIndex442)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex443 = (decoder.readIndex()); + if (unionIndex443 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(443, null); + } else { + if (unionIndex443 == 1) { + Utf8 charSequence443; + Object oldString443 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(443); + if (oldString443 instanceof Utf8) { + charSequence443 = (decoder).readString(((Utf8) oldString443)); + } else { + charSequence443 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(443, charSequence443); + } else { + throw new RuntimeException(("Illegal union index for 'F443': "+ unionIndex443)); + } + } + int unionIndex444 = (decoder.readIndex()); + if (unionIndex444 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(444, null); + } else { + if (unionIndex444 == 1) { + Utf8 charSequence444; + Object oldString444 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(444); + if (oldString444 instanceof Utf8) { + charSequence444 = (decoder).readString(((Utf8) oldString444)); + } else { + charSequence444 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(444, charSequence444); + } else { + throw new RuntimeException(("Illegal union index for 'F444': "+ unionIndex444)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex445 = (decoder.readIndex()); + if (unionIndex445 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(445, null); + } else { + if (unionIndex445 == 1) { + Utf8 charSequence445; + Object oldString445 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(445); + if (oldString445 instanceof Utf8) { + charSequence445 = (decoder).readString(((Utf8) oldString445)); + } else { + charSequence445 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(445, charSequence445); + } else { + throw new RuntimeException(("Illegal union index for 'F445': "+ unionIndex445)); + } + } + int unionIndex446 = (decoder.readIndex()); + if (unionIndex446 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(446, null); + } else { + if (unionIndex446 == 1) { + Utf8 charSequence446; + Object oldString446 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(446); + if (oldString446 instanceof Utf8) { + charSequence446 = (decoder).readString(((Utf8) oldString446)); + } else { + charSequence446 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(446, charSequence446); + } else { + throw new RuntimeException(("Illegal union index for 'F446': "+ unionIndex446)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex447 = (decoder.readIndex()); + if (unionIndex447 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(447, null); + } else { + if (unionIndex447 == 1) { + Utf8 charSequence447; + Object oldString447 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(447); + if (oldString447 instanceof Utf8) { + charSequence447 = (decoder).readString(((Utf8) oldString447)); + } else { + charSequence447 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(447, charSequence447); + } else { + throw new RuntimeException(("Illegal union index for 'F447': "+ unionIndex447)); + } + } + int unionIndex448 = (decoder.readIndex()); + if (unionIndex448 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(448, null); + } else { + if (unionIndex448 == 1) { + Utf8 charSequence448; + Object oldString448 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(448); + if (oldString448 instanceof Utf8) { + charSequence448 = (decoder).readString(((Utf8) oldString448)); + } else { + charSequence448 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(448, charSequence448); + } else { + throw new RuntimeException(("Illegal union index for 'F448': "+ unionIndex448)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex449 = (decoder.readIndex()); + if (unionIndex449 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(449, null); + } else { + if (unionIndex449 == 1) { + Utf8 charSequence449; + Object oldString449 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(449); + if (oldString449 instanceof Utf8) { + charSequence449 = (decoder).readString(((Utf8) oldString449)); + } else { + charSequence449 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(449, charSequence449); + } else { + throw new RuntimeException(("Illegal union index for 'F449': "+ unionIndex449)); + } + } + int unionIndex450 = (decoder.readIndex()); + if (unionIndex450 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(450, null); + } else { + if (unionIndex450 == 1) { + Utf8 charSequence450; + Object oldString450 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(450); + if (oldString450 instanceof Utf8) { + charSequence450 = (decoder).readString(((Utf8) oldString450)); + } else { + charSequence450 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(450, charSequence450); + } else { + throw new RuntimeException(("Illegal union index for 'F450': "+ unionIndex450)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex451 = (decoder.readIndex()); + if (unionIndex451 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(451, null); + } else { + if (unionIndex451 == 1) { + Utf8 charSequence451; + Object oldString451 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(451); + if (oldString451 instanceof Utf8) { + charSequence451 = (decoder).readString(((Utf8) oldString451)); + } else { + charSequence451 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(451, charSequence451); + } else { + throw new RuntimeException(("Illegal union index for 'F451': "+ unionIndex451)); + } + } + int unionIndex452 = (decoder.readIndex()); + if (unionIndex452 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(452, null); + } else { + if (unionIndex452 == 1) { + Utf8 charSequence452; + Object oldString452 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(452); + if (oldString452 instanceof Utf8) { + charSequence452 = (decoder).readString(((Utf8) oldString452)); + } else { + charSequence452 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(452, charSequence452); + } else { + throw new RuntimeException(("Illegal union index for 'F452': "+ unionIndex452)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex453 = (decoder.readIndex()); + if (unionIndex453 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(453, null); + } else { + if (unionIndex453 == 1) { + Utf8 charSequence453; + Object oldString453 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(453); + if (oldString453 instanceof Utf8) { + charSequence453 = (decoder).readString(((Utf8) oldString453)); + } else { + charSequence453 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(453, charSequence453); + } else { + throw new RuntimeException(("Illegal union index for 'F453': "+ unionIndex453)); + } + } + int unionIndex454 = (decoder.readIndex()); + if (unionIndex454 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(454, null); + } else { + if (unionIndex454 == 1) { + Utf8 charSequence454; + Object oldString454 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(454); + if (oldString454 instanceof Utf8) { + charSequence454 = (decoder).readString(((Utf8) oldString454)); + } else { + charSequence454 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(454, charSequence454); + } else { + throw new RuntimeException(("Illegal union index for 'F454': "+ unionIndex454)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex455 = (decoder.readIndex()); + if (unionIndex455 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(455, null); + } else { + if (unionIndex455 == 1) { + Utf8 charSequence455; + Object oldString455 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(455); + if (oldString455 instanceof Utf8) { + charSequence455 = (decoder).readString(((Utf8) oldString455)); + } else { + charSequence455 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(455, charSequence455); + } else { + throw new RuntimeException(("Illegal union index for 'F455': "+ unionIndex455)); + } + } + int unionIndex456 = (decoder.readIndex()); + if (unionIndex456 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(456, null); + } else { + if (unionIndex456 == 1) { + Utf8 charSequence456; + Object oldString456 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(456); + if (oldString456 instanceof Utf8) { + charSequence456 = (decoder).readString(((Utf8) oldString456)); + } else { + charSequence456 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(456, charSequence456); + } else { + throw new RuntimeException(("Illegal union index for 'F456': "+ unionIndex456)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex457 = (decoder.readIndex()); + if (unionIndex457 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(457, null); + } else { + if (unionIndex457 == 1) { + Utf8 charSequence457; + Object oldString457 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(457); + if (oldString457 instanceof Utf8) { + charSequence457 = (decoder).readString(((Utf8) oldString457)); + } else { + charSequence457 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(457, charSequence457); + } else { + throw new RuntimeException(("Illegal union index for 'F457': "+ unionIndex457)); + } + } + int unionIndex458 = (decoder.readIndex()); + if (unionIndex458 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(458, null); + } else { + if (unionIndex458 == 1) { + Utf8 charSequence458; + Object oldString458 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(458); + if (oldString458 instanceof Utf8) { + charSequence458 = (decoder).readString(((Utf8) oldString458)); + } else { + charSequence458 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(458, charSequence458); + } else { + throw new RuntimeException(("Illegal union index for 'F458': "+ unionIndex458)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex459 = (decoder.readIndex()); + if (unionIndex459 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(459, null); + } else { + if (unionIndex459 == 1) { + Utf8 charSequence459; + Object oldString459 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(459); + if (oldString459 instanceof Utf8) { + charSequence459 = (decoder).readString(((Utf8) oldString459)); + } else { + charSequence459 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(459, charSequence459); + } else { + throw new RuntimeException(("Illegal union index for 'F459': "+ unionIndex459)); + } + } + int unionIndex460 = (decoder.readIndex()); + if (unionIndex460 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(460, null); + } else { + if (unionIndex460 == 1) { + Utf8 charSequence460; + Object oldString460 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(460); + if (oldString460 instanceof Utf8) { + charSequence460 = (decoder).readString(((Utf8) oldString460)); + } else { + charSequence460 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(460, charSequence460); + } else { + throw new RuntimeException(("Illegal union index for 'F460': "+ unionIndex460)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex461 = (decoder.readIndex()); + if (unionIndex461 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(461, null); + } else { + if (unionIndex461 == 1) { + Utf8 charSequence461; + Object oldString461 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(461); + if (oldString461 instanceof Utf8) { + charSequence461 = (decoder).readString(((Utf8) oldString461)); + } else { + charSequence461 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(461, charSequence461); + } else { + throw new RuntimeException(("Illegal union index for 'F461': "+ unionIndex461)); + } + } + int unionIndex462 = (decoder.readIndex()); + if (unionIndex462 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(462, null); + } else { + if (unionIndex462 == 1) { + Utf8 charSequence462; + Object oldString462 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(462); + if (oldString462 instanceof Utf8) { + charSequence462 = (decoder).readString(((Utf8) oldString462)); + } else { + charSequence462 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(462, charSequence462); + } else { + throw new RuntimeException(("Illegal union index for 'F462': "+ unionIndex462)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex463 = (decoder.readIndex()); + if (unionIndex463 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(463, null); + } else { + if (unionIndex463 == 1) { + Utf8 charSequence463; + Object oldString463 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(463); + if (oldString463 instanceof Utf8) { + charSequence463 = (decoder).readString(((Utf8) oldString463)); + } else { + charSequence463 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(463, charSequence463); + } else { + throw new RuntimeException(("Illegal union index for 'F463': "+ unionIndex463)); + } + } + int unionIndex464 = (decoder.readIndex()); + if (unionIndex464 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(464, null); + } else { + if (unionIndex464 == 1) { + Utf8 charSequence464; + Object oldString464 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(464); + if (oldString464 instanceof Utf8) { + charSequence464 = (decoder).readString(((Utf8) oldString464)); + } else { + charSequence464 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(464, charSequence464); + } else { + throw new RuntimeException(("Illegal union index for 'F464': "+ unionIndex464)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex465 = (decoder.readIndex()); + if (unionIndex465 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(465, null); + } else { + if (unionIndex465 == 1) { + Utf8 charSequence465; + Object oldString465 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(465); + if (oldString465 instanceof Utf8) { + charSequence465 = (decoder).readString(((Utf8) oldString465)); + } else { + charSequence465 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(465, charSequence465); + } else { + throw new RuntimeException(("Illegal union index for 'F465': "+ unionIndex465)); + } + } + int unionIndex466 = (decoder.readIndex()); + if (unionIndex466 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(466, null); + } else { + if (unionIndex466 == 1) { + Utf8 charSequence466; + Object oldString466 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(466); + if (oldString466 instanceof Utf8) { + charSequence466 = (decoder).readString(((Utf8) oldString466)); + } else { + charSequence466 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(466, charSequence466); + } else { + throw new RuntimeException(("Illegal union index for 'F466': "+ unionIndex466)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex467 = (decoder.readIndex()); + if (unionIndex467 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(467, null); + } else { + if (unionIndex467 == 1) { + Utf8 charSequence467; + Object oldString467 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(467); + if (oldString467 instanceof Utf8) { + charSequence467 = (decoder).readString(((Utf8) oldString467)); + } else { + charSequence467 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(467, charSequence467); + } else { + throw new RuntimeException(("Illegal union index for 'F467': "+ unionIndex467)); + } + } + int unionIndex468 = (decoder.readIndex()); + if (unionIndex468 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(468, null); + } else { + if (unionIndex468 == 1) { + Utf8 charSequence468; + Object oldString468 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(468); + if (oldString468 instanceof Utf8) { + charSequence468 = (decoder).readString(((Utf8) oldString468)); + } else { + charSequence468 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(468, charSequence468); + } else { + throw new RuntimeException(("Illegal union index for 'F468': "+ unionIndex468)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex469 = (decoder.readIndex()); + if (unionIndex469 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(469, null); + } else { + if (unionIndex469 == 1) { + Utf8 charSequence469; + Object oldString469 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(469); + if (oldString469 instanceof Utf8) { + charSequence469 = (decoder).readString(((Utf8) oldString469)); + } else { + charSequence469 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(469, charSequence469); + } else { + throw new RuntimeException(("Illegal union index for 'F469': "+ unionIndex469)); + } + } + int unionIndex470 = (decoder.readIndex()); + if (unionIndex470 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(470, null); + } else { + if (unionIndex470 == 1) { + Utf8 charSequence470; + Object oldString470 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(470); + if (oldString470 instanceof Utf8) { + charSequence470 = (decoder).readString(((Utf8) oldString470)); + } else { + charSequence470 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(470, charSequence470); + } else { + throw new RuntimeException(("Illegal union index for 'F470': "+ unionIndex470)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex471 = (decoder.readIndex()); + if (unionIndex471 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(471, null); + } else { + if (unionIndex471 == 1) { + Utf8 charSequence471; + Object oldString471 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(471); + if (oldString471 instanceof Utf8) { + charSequence471 = (decoder).readString(((Utf8) oldString471)); + } else { + charSequence471 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(471, charSequence471); + } else { + throw new RuntimeException(("Illegal union index for 'F471': "+ unionIndex471)); + } + } + int unionIndex472 = (decoder.readIndex()); + if (unionIndex472 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(472, null); + } else { + if (unionIndex472 == 1) { + Utf8 charSequence472; + Object oldString472 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(472); + if (oldString472 instanceof Utf8) { + charSequence472 = (decoder).readString(((Utf8) oldString472)); + } else { + charSequence472 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(472, charSequence472); + } else { + throw new RuntimeException(("Illegal union index for 'F472': "+ unionIndex472)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex473 = (decoder.readIndex()); + if (unionIndex473 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(473, null); + } else { + if (unionIndex473 == 1) { + Utf8 charSequence473; + Object oldString473 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(473); + if (oldString473 instanceof Utf8) { + charSequence473 = (decoder).readString(((Utf8) oldString473)); + } else { + charSequence473 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(473, charSequence473); + } else { + throw new RuntimeException(("Illegal union index for 'F473': "+ unionIndex473)); + } + } + int unionIndex474 = (decoder.readIndex()); + if (unionIndex474 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(474, null); + } else { + if (unionIndex474 == 1) { + Utf8 charSequence474; + Object oldString474 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(474); + if (oldString474 instanceof Utf8) { + charSequence474 = (decoder).readString(((Utf8) oldString474)); + } else { + charSequence474 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(474, charSequence474); + } else { + throw new RuntimeException(("Illegal union index for 'F474': "+ unionIndex474)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex475 = (decoder.readIndex()); + if (unionIndex475 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(475, null); + } else { + if (unionIndex475 == 1) { + Utf8 charSequence475; + Object oldString475 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(475); + if (oldString475 instanceof Utf8) { + charSequence475 = (decoder).readString(((Utf8) oldString475)); + } else { + charSequence475 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(475, charSequence475); + } else { + throw new RuntimeException(("Illegal union index for 'F475': "+ unionIndex475)); + } + } + int unionIndex476 = (decoder.readIndex()); + if (unionIndex476 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(476, null); + } else { + if (unionIndex476 == 1) { + Utf8 charSequence476; + Object oldString476 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(476); + if (oldString476 instanceof Utf8) { + charSequence476 = (decoder).readString(((Utf8) oldString476)); + } else { + charSequence476 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(476, charSequence476); + } else { + throw new RuntimeException(("Illegal union index for 'F476': "+ unionIndex476)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex477 = (decoder.readIndex()); + if (unionIndex477 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(477, null); + } else { + if (unionIndex477 == 1) { + Utf8 charSequence477; + Object oldString477 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(477); + if (oldString477 instanceof Utf8) { + charSequence477 = (decoder).readString(((Utf8) oldString477)); + } else { + charSequence477 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(477, charSequence477); + } else { + throw new RuntimeException(("Illegal union index for 'F477': "+ unionIndex477)); + } + } + int unionIndex478 = (decoder.readIndex()); + if (unionIndex478 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(478, null); + } else { + if (unionIndex478 == 1) { + Utf8 charSequence478; + Object oldString478 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(478); + if (oldString478 instanceof Utf8) { + charSequence478 = (decoder).readString(((Utf8) oldString478)); + } else { + charSequence478 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(478, charSequence478); + } else { + throw new RuntimeException(("Illegal union index for 'F478': "+ unionIndex478)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex479 = (decoder.readIndex()); + if (unionIndex479 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(479, null); + } else { + if (unionIndex479 == 1) { + Utf8 charSequence479; + Object oldString479 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(479); + if (oldString479 instanceof Utf8) { + charSequence479 = (decoder).readString(((Utf8) oldString479)); + } else { + charSequence479 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(479, charSequence479); + } else { + throw new RuntimeException(("Illegal union index for 'F479': "+ unionIndex479)); + } + } + int unionIndex480 = (decoder.readIndex()); + if (unionIndex480 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(480, null); + } else { + if (unionIndex480 == 1) { + Utf8 charSequence480; + Object oldString480 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(480); + if (oldString480 instanceof Utf8) { + charSequence480 = (decoder).readString(((Utf8) oldString480)); + } else { + charSequence480 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(480, charSequence480); + } else { + throw new RuntimeException(("Illegal union index for 'F480': "+ unionIndex480)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex481 = (decoder.readIndex()); + if (unionIndex481 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(481, null); + } else { + if (unionIndex481 == 1) { + Utf8 charSequence481; + Object oldString481 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(481); + if (oldString481 instanceof Utf8) { + charSequence481 = (decoder).readString(((Utf8) oldString481)); + } else { + charSequence481 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(481, charSequence481); + } else { + throw new RuntimeException(("Illegal union index for 'F481': "+ unionIndex481)); + } + } + int unionIndex482 = (decoder.readIndex()); + if (unionIndex482 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(482, null); + } else { + if (unionIndex482 == 1) { + Utf8 charSequence482; + Object oldString482 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(482); + if (oldString482 instanceof Utf8) { + charSequence482 = (decoder).readString(((Utf8) oldString482)); + } else { + charSequence482 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(482, charSequence482); + } else { + throw new RuntimeException(("Illegal union index for 'F482': "+ unionIndex482)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex483 = (decoder.readIndex()); + if (unionIndex483 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(483, null); + } else { + if (unionIndex483 == 1) { + Utf8 charSequence483; + Object oldString483 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(483); + if (oldString483 instanceof Utf8) { + charSequence483 = (decoder).readString(((Utf8) oldString483)); + } else { + charSequence483 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(483, charSequence483); + } else { + throw new RuntimeException(("Illegal union index for 'F483': "+ unionIndex483)); + } + } + int unionIndex484 = (decoder.readIndex()); + if (unionIndex484 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(484, null); + } else { + if (unionIndex484 == 1) { + Utf8 charSequence484; + Object oldString484 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(484); + if (oldString484 instanceof Utf8) { + charSequence484 = (decoder).readString(((Utf8) oldString484)); + } else { + charSequence484 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(484, charSequence484); + } else { + throw new RuntimeException(("Illegal union index for 'F484': "+ unionIndex484)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex485 = (decoder.readIndex()); + if (unionIndex485 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(485, null); + } else { + if (unionIndex485 == 1) { + Utf8 charSequence485; + Object oldString485 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(485); + if (oldString485 instanceof Utf8) { + charSequence485 = (decoder).readString(((Utf8) oldString485)); + } else { + charSequence485 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(485, charSequence485); + } else { + throw new RuntimeException(("Illegal union index for 'F485': "+ unionIndex485)); + } + } + int unionIndex486 = (decoder.readIndex()); + if (unionIndex486 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(486, null); + } else { + if (unionIndex486 == 1) { + Utf8 charSequence486; + Object oldString486 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(486); + if (oldString486 instanceof Utf8) { + charSequence486 = (decoder).readString(((Utf8) oldString486)); + } else { + charSequence486 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(486, charSequence486); + } else { + throw new RuntimeException(("Illegal union index for 'F486': "+ unionIndex486)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex487 = (decoder.readIndex()); + if (unionIndex487 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(487, null); + } else { + if (unionIndex487 == 1) { + Utf8 charSequence487; + Object oldString487 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(487); + if (oldString487 instanceof Utf8) { + charSequence487 = (decoder).readString(((Utf8) oldString487)); + } else { + charSequence487 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(487, charSequence487); + } else { + throw new RuntimeException(("Illegal union index for 'F487': "+ unionIndex487)); + } + } + int unionIndex488 = (decoder.readIndex()); + if (unionIndex488 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(488, null); + } else { + if (unionIndex488 == 1) { + Utf8 charSequence488; + Object oldString488 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(488); + if (oldString488 instanceof Utf8) { + charSequence488 = (decoder).readString(((Utf8) oldString488)); + } else { + charSequence488 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(488, charSequence488); + } else { + throw new RuntimeException(("Illegal union index for 'F488': "+ unionIndex488)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex489 = (decoder.readIndex()); + if (unionIndex489 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(489, null); + } else { + if (unionIndex489 == 1) { + Utf8 charSequence489; + Object oldString489 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(489); + if (oldString489 instanceof Utf8) { + charSequence489 = (decoder).readString(((Utf8) oldString489)); + } else { + charSequence489 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(489, charSequence489); + } else { + throw new RuntimeException(("Illegal union index for 'F489': "+ unionIndex489)); + } + } + int unionIndex490 = (decoder.readIndex()); + if (unionIndex490 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(490, null); + } else { + if (unionIndex490 == 1) { + Utf8 charSequence490; + Object oldString490 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(490); + if (oldString490 instanceof Utf8) { + charSequence490 = (decoder).readString(((Utf8) oldString490)); + } else { + charSequence490 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(490, charSequence490); + } else { + throw new RuntimeException(("Illegal union index for 'F490': "+ unionIndex490)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex491 = (decoder.readIndex()); + if (unionIndex491 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(491, null); + } else { + if (unionIndex491 == 1) { + Utf8 charSequence491; + Object oldString491 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(491); + if (oldString491 instanceof Utf8) { + charSequence491 = (decoder).readString(((Utf8) oldString491)); + } else { + charSequence491 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(491, charSequence491); + } else { + throw new RuntimeException(("Illegal union index for 'F491': "+ unionIndex491)); + } + } + int unionIndex492 = (decoder.readIndex()); + if (unionIndex492 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(492, null); + } else { + if (unionIndex492 == 1) { + Utf8 charSequence492; + Object oldString492 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(492); + if (oldString492 instanceof Utf8) { + charSequence492 = (decoder).readString(((Utf8) oldString492)); + } else { + charSequence492 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(492, charSequence492); + } else { + throw new RuntimeException(("Illegal union index for 'F492': "+ unionIndex492)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex493 = (decoder.readIndex()); + if (unionIndex493 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(493, null); + } else { + if (unionIndex493 == 1) { + Utf8 charSequence493; + Object oldString493 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(493); + if (oldString493 instanceof Utf8) { + charSequence493 = (decoder).readString(((Utf8) oldString493)); + } else { + charSequence493 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(493, charSequence493); + } else { + throw new RuntimeException(("Illegal union index for 'F493': "+ unionIndex493)); + } + } + int unionIndex494 = (decoder.readIndex()); + if (unionIndex494 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(494, null); + } else { + if (unionIndex494 == 1) { + Utf8 charSequence494; + Object oldString494 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(494); + if (oldString494 instanceof Utf8) { + charSequence494 = (decoder).readString(((Utf8) oldString494)); + } else { + charSequence494 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(494, charSequence494); + } else { + throw new RuntimeException(("Illegal union index for 'F494': "+ unionIndex494)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex495 = (decoder.readIndex()); + if (unionIndex495 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(495, null); + } else { + if (unionIndex495 == 1) { + Utf8 charSequence495; + Object oldString495 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(495); + if (oldString495 instanceof Utf8) { + charSequence495 = (decoder).readString(((Utf8) oldString495)); + } else { + charSequence495 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(495, charSequence495); + } else { + throw new RuntimeException(("Illegal union index for 'F495': "+ unionIndex495)); + } + } + int unionIndex496 = (decoder.readIndex()); + if (unionIndex496 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(496, null); + } else { + if (unionIndex496 == 1) { + Utf8 charSequence496; + Object oldString496 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(496); + if (oldString496 instanceof Utf8) { + charSequence496 = (decoder).readString(((Utf8) oldString496)); + } else { + charSequence496 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(496, charSequence496); + } else { + throw new RuntimeException(("Illegal union index for 'F496': "+ unionIndex496)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex497 = (decoder.readIndex()); + if (unionIndex497 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(497, null); + } else { + if (unionIndex497 == 1) { + Utf8 charSequence497; + Object oldString497 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(497); + if (oldString497 instanceof Utf8) { + charSequence497 = (decoder).readString(((Utf8) oldString497)); + } else { + charSequence497 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(497, charSequence497); + } else { + throw new RuntimeException(("Illegal union index for 'F497': "+ unionIndex497)); + } + } + int unionIndex498 = (decoder.readIndex()); + if (unionIndex498 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(498, null); + } else { + if (unionIndex498 == 1) { + Utf8 charSequence498; + Object oldString498 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(498); + if (oldString498 instanceof Utf8) { + charSequence498 = (decoder).readString(((Utf8) oldString498)); + } else { + charSequence498 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(498, charSequence498); + } else { + throw new RuntimeException(("Illegal union index for 'F498': "+ unionIndex498)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex499 = (decoder.readIndex()); + if (unionIndex499 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(499, null); + } else { + if (unionIndex499 == 1) { + Utf8 charSequence499; + Object oldString499 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(499); + if (oldString499 instanceof Utf8) { + charSequence499 = (decoder).readString(((Utf8) oldString499)); + } else { + charSequence499 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(499, charSequence499); + } else { + throw new RuntimeException(("Illegal union index for 'F499': "+ unionIndex499)); + } + } + int unionIndex500 = (decoder.readIndex()); + if (unionIndex500 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(500, null); + } else { + if (unionIndex500 == 1) { + Utf8 charSequence500; + Object oldString500 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(500); + if (oldString500 instanceof Utf8) { + charSequence500 = (decoder).readString(((Utf8) oldString500)); + } else { + charSequence500 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(500, charSequence500); + } else { + throw new RuntimeException(("Illegal union index for 'F500': "+ unionIndex500)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex501 = (decoder.readIndex()); + if (unionIndex501 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(501, null); + } else { + if (unionIndex501 == 1) { + Utf8 charSequence501; + Object oldString501 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(501); + if (oldString501 instanceof Utf8) { + charSequence501 = (decoder).readString(((Utf8) oldString501)); + } else { + charSequence501 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(501, charSequence501); + } else { + throw new RuntimeException(("Illegal union index for 'F501': "+ unionIndex501)); + } + } + int unionIndex502 = (decoder.readIndex()); + if (unionIndex502 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(502, null); + } else { + if (unionIndex502 == 1) { + Utf8 charSequence502; + Object oldString502 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(502); + if (oldString502 instanceof Utf8) { + charSequence502 = (decoder).readString(((Utf8) oldString502)); + } else { + charSequence502 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(502, charSequence502); + } else { + throw new RuntimeException(("Illegal union index for 'F502': "+ unionIndex502)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex503 = (decoder.readIndex()); + if (unionIndex503 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(503, null); + } else { + if (unionIndex503 == 1) { + Utf8 charSequence503; + Object oldString503 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(503); + if (oldString503 instanceof Utf8) { + charSequence503 = (decoder).readString(((Utf8) oldString503)); + } else { + charSequence503 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(503, charSequence503); + } else { + throw new RuntimeException(("Illegal union index for 'F503': "+ unionIndex503)); + } + } + int unionIndex504 = (decoder.readIndex()); + if (unionIndex504 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(504, null); + } else { + if (unionIndex504 == 1) { + Utf8 charSequence504; + Object oldString504 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(504); + if (oldString504 instanceof Utf8) { + charSequence504 = (decoder).readString(((Utf8) oldString504)); + } else { + charSequence504 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(504, charSequence504); + } else { + throw new RuntimeException(("Illegal union index for 'F504': "+ unionIndex504)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex505 = (decoder.readIndex()); + if (unionIndex505 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(505, null); + } else { + if (unionIndex505 == 1) { + Utf8 charSequence505; + Object oldString505 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(505); + if (oldString505 instanceof Utf8) { + charSequence505 = (decoder).readString(((Utf8) oldString505)); + } else { + charSequence505 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(505, charSequence505); + } else { + throw new RuntimeException(("Illegal union index for 'F505': "+ unionIndex505)); + } + } + int unionIndex506 = (decoder.readIndex()); + if (unionIndex506 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(506, null); + } else { + if (unionIndex506 == 1) { + Utf8 charSequence506; + Object oldString506 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(506); + if (oldString506 instanceof Utf8) { + charSequence506 = (decoder).readString(((Utf8) oldString506)); + } else { + charSequence506 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(506, charSequence506); + } else { + throw new RuntimeException(("Illegal union index for 'F506': "+ unionIndex506)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex507 = (decoder.readIndex()); + if (unionIndex507 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(507, null); + } else { + if (unionIndex507 == 1) { + Utf8 charSequence507; + Object oldString507 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(507); + if (oldString507 instanceof Utf8) { + charSequence507 = (decoder).readString(((Utf8) oldString507)); + } else { + charSequence507 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(507, charSequence507); + } else { + throw new RuntimeException(("Illegal union index for 'F507': "+ unionIndex507)); + } + } + int unionIndex508 = (decoder.readIndex()); + if (unionIndex508 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(508, null); + } else { + if (unionIndex508 == 1) { + Utf8 charSequence508; + Object oldString508 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(508); + if (oldString508 instanceof Utf8) { + charSequence508 = (decoder).readString(((Utf8) oldString508)); + } else { + charSequence508 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(508, charSequence508); + } else { + throw new RuntimeException(("Illegal union index for 'F508': "+ unionIndex508)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex509 = (decoder.readIndex()); + if (unionIndex509 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(509, null); + } else { + if (unionIndex509 == 1) { + Utf8 charSequence509; + Object oldString509 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(509); + if (oldString509 instanceof Utf8) { + charSequence509 = (decoder).readString(((Utf8) oldString509)); + } else { + charSequence509 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(509, charSequence509); + } else { + throw new RuntimeException(("Illegal union index for 'F509': "+ unionIndex509)); + } + } + int unionIndex510 = (decoder.readIndex()); + if (unionIndex510 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(510, null); + } else { + if (unionIndex510 == 1) { + Utf8 charSequence510; + Object oldString510 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(510); + if (oldString510 instanceof Utf8) { + charSequence510 = (decoder).readString(((Utf8) oldString510)); + } else { + charSequence510 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(510, charSequence510); + } else { + throw new RuntimeException(("Illegal union index for 'F510': "+ unionIndex510)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex511 = (decoder.readIndex()); + if (unionIndex511 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(511, null); + } else { + if (unionIndex511 == 1) { + Utf8 charSequence511; + Object oldString511 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(511); + if (oldString511 instanceof Utf8) { + charSequence511 = (decoder).readString(((Utf8) oldString511)); + } else { + charSequence511 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(511, charSequence511); + } else { + throw new RuntimeException(("Illegal union index for 'F511': "+ unionIndex511)); + } + } + int unionIndex512 = (decoder.readIndex()); + if (unionIndex512 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(512, null); + } else { + if (unionIndex512 == 1) { + Utf8 charSequence512; + Object oldString512 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(512); + if (oldString512 instanceof Utf8) { + charSequence512 = (decoder).readString(((Utf8) oldString512)); + } else { + charSequence512 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(512, charSequence512); + } else { + throw new RuntimeException(("Illegal union index for 'F512': "+ unionIndex512)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex513 = (decoder.readIndex()); + if (unionIndex513 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(513, null); + } else { + if (unionIndex513 == 1) { + Utf8 charSequence513; + Object oldString513 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(513); + if (oldString513 instanceof Utf8) { + charSequence513 = (decoder).readString(((Utf8) oldString513)); + } else { + charSequence513 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(513, charSequence513); + } else { + throw new RuntimeException(("Illegal union index for 'F513': "+ unionIndex513)); + } + } + int unionIndex514 = (decoder.readIndex()); + if (unionIndex514 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(514, null); + } else { + if (unionIndex514 == 1) { + Utf8 charSequence514; + Object oldString514 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(514); + if (oldString514 instanceof Utf8) { + charSequence514 = (decoder).readString(((Utf8) oldString514)); + } else { + charSequence514 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(514, charSequence514); + } else { + throw new RuntimeException(("Illegal union index for 'F514': "+ unionIndex514)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex515 = (decoder.readIndex()); + if (unionIndex515 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(515, null); + } else { + if (unionIndex515 == 1) { + Utf8 charSequence515; + Object oldString515 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(515); + if (oldString515 instanceof Utf8) { + charSequence515 = (decoder).readString(((Utf8) oldString515)); + } else { + charSequence515 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(515, charSequence515); + } else { + throw new RuntimeException(("Illegal union index for 'F515': "+ unionIndex515)); + } + } + int unionIndex516 = (decoder.readIndex()); + if (unionIndex516 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(516, null); + } else { + if (unionIndex516 == 1) { + Utf8 charSequence516; + Object oldString516 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(516); + if (oldString516 instanceof Utf8) { + charSequence516 = (decoder).readString(((Utf8) oldString516)); + } else { + charSequence516 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(516, charSequence516); + } else { + throw new RuntimeException(("Illegal union index for 'F516': "+ unionIndex516)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex517 = (decoder.readIndex()); + if (unionIndex517 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(517, null); + } else { + if (unionIndex517 == 1) { + Utf8 charSequence517; + Object oldString517 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(517); + if (oldString517 instanceof Utf8) { + charSequence517 = (decoder).readString(((Utf8) oldString517)); + } else { + charSequence517 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(517, charSequence517); + } else { + throw new RuntimeException(("Illegal union index for 'F517': "+ unionIndex517)); + } + } + int unionIndex518 = (decoder.readIndex()); + if (unionIndex518 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(518, null); + } else { + if (unionIndex518 == 1) { + Utf8 charSequence518; + Object oldString518 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(518); + if (oldString518 instanceof Utf8) { + charSequence518 = (decoder).readString(((Utf8) oldString518)); + } else { + charSequence518 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(518, charSequence518); + } else { + throw new RuntimeException(("Illegal union index for 'F518': "+ unionIndex518)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex519 = (decoder.readIndex()); + if (unionIndex519 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(519, null); + } else { + if (unionIndex519 == 1) { + Utf8 charSequence519; + Object oldString519 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(519); + if (oldString519 instanceof Utf8) { + charSequence519 = (decoder).readString(((Utf8) oldString519)); + } else { + charSequence519 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(519, charSequence519); + } else { + throw new RuntimeException(("Illegal union index for 'F519': "+ unionIndex519)); + } + } + int unionIndex520 = (decoder.readIndex()); + if (unionIndex520 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(520, null); + } else { + if (unionIndex520 == 1) { + Utf8 charSequence520; + Object oldString520 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(520); + if (oldString520 instanceof Utf8) { + charSequence520 = (decoder).readString(((Utf8) oldString520)); + } else { + charSequence520 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(520, charSequence520); + } else { + throw new RuntimeException(("Illegal union index for 'F520': "+ unionIndex520)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex521 = (decoder.readIndex()); + if (unionIndex521 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(521, null); + } else { + if (unionIndex521 == 1) { + Utf8 charSequence521; + Object oldString521 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(521); + if (oldString521 instanceof Utf8) { + charSequence521 = (decoder).readString(((Utf8) oldString521)); + } else { + charSequence521 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(521, charSequence521); + } else { + throw new RuntimeException(("Illegal union index for 'F521': "+ unionIndex521)); + } + } + int unionIndex522 = (decoder.readIndex()); + if (unionIndex522 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(522, null); + } else { + if (unionIndex522 == 1) { + Utf8 charSequence522; + Object oldString522 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(522); + if (oldString522 instanceof Utf8) { + charSequence522 = (decoder).readString(((Utf8) oldString522)); + } else { + charSequence522 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(522, charSequence522); + } else { + throw new RuntimeException(("Illegal union index for 'F522': "+ unionIndex522)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex523 = (decoder.readIndex()); + if (unionIndex523 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(523, null); + } else { + if (unionIndex523 == 1) { + Utf8 charSequence523; + Object oldString523 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(523); + if (oldString523 instanceof Utf8) { + charSequence523 = (decoder).readString(((Utf8) oldString523)); + } else { + charSequence523 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(523, charSequence523); + } else { + throw new RuntimeException(("Illegal union index for 'F523': "+ unionIndex523)); + } + } + int unionIndex524 = (decoder.readIndex()); + if (unionIndex524 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(524, null); + } else { + if (unionIndex524 == 1) { + Utf8 charSequence524; + Object oldString524 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(524); + if (oldString524 instanceof Utf8) { + charSequence524 = (decoder).readString(((Utf8) oldString524)); + } else { + charSequence524 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(524, charSequence524); + } else { + throw new RuntimeException(("Illegal union index for 'F524': "+ unionIndex524)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex525 = (decoder.readIndex()); + if (unionIndex525 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(525, null); + } else { + if (unionIndex525 == 1) { + Utf8 charSequence525; + Object oldString525 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(525); + if (oldString525 instanceof Utf8) { + charSequence525 = (decoder).readString(((Utf8) oldString525)); + } else { + charSequence525 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(525, charSequence525); + } else { + throw new RuntimeException(("Illegal union index for 'F525': "+ unionIndex525)); + } + } + int unionIndex526 = (decoder.readIndex()); + if (unionIndex526 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(526, null); + } else { + if (unionIndex526 == 1) { + Utf8 charSequence526; + Object oldString526 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(526); + if (oldString526 instanceof Utf8) { + charSequence526 = (decoder).readString(((Utf8) oldString526)); + } else { + charSequence526 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(526, charSequence526); + } else { + throw new RuntimeException(("Illegal union index for 'F526': "+ unionIndex526)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex527 = (decoder.readIndex()); + if (unionIndex527 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(527, null); + } else { + if (unionIndex527 == 1) { + Utf8 charSequence527; + Object oldString527 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(527); + if (oldString527 instanceof Utf8) { + charSequence527 = (decoder).readString(((Utf8) oldString527)); + } else { + charSequence527 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(527, charSequence527); + } else { + throw new RuntimeException(("Illegal union index for 'F527': "+ unionIndex527)); + } + } + int unionIndex528 = (decoder.readIndex()); + if (unionIndex528 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(528, null); + } else { + if (unionIndex528 == 1) { + Utf8 charSequence528; + Object oldString528 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(528); + if (oldString528 instanceof Utf8) { + charSequence528 = (decoder).readString(((Utf8) oldString528)); + } else { + charSequence528 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(528, charSequence528); + } else { + throw new RuntimeException(("Illegal union index for 'F528': "+ unionIndex528)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex529 = (decoder.readIndex()); + if (unionIndex529 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(529, null); + } else { + if (unionIndex529 == 1) { + Utf8 charSequence529; + Object oldString529 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(529); + if (oldString529 instanceof Utf8) { + charSequence529 = (decoder).readString(((Utf8) oldString529)); + } else { + charSequence529 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(529, charSequence529); + } else { + throw new RuntimeException(("Illegal union index for 'F529': "+ unionIndex529)); + } + } + int unionIndex530 = (decoder.readIndex()); + if (unionIndex530 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(530, null); + } else { + if (unionIndex530 == 1) { + Utf8 charSequence530; + Object oldString530 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(530); + if (oldString530 instanceof Utf8) { + charSequence530 = (decoder).readString(((Utf8) oldString530)); + } else { + charSequence530 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(530, charSequence530); + } else { + throw new RuntimeException(("Illegal union index for 'F530': "+ unionIndex530)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex531 = (decoder.readIndex()); + if (unionIndex531 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(531, null); + } else { + if (unionIndex531 == 1) { + Utf8 charSequence531; + Object oldString531 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(531); + if (oldString531 instanceof Utf8) { + charSequence531 = (decoder).readString(((Utf8) oldString531)); + } else { + charSequence531 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(531, charSequence531); + } else { + throw new RuntimeException(("Illegal union index for 'F531': "+ unionIndex531)); + } + } + int unionIndex532 = (decoder.readIndex()); + if (unionIndex532 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(532, null); + } else { + if (unionIndex532 == 1) { + Utf8 charSequence532; + Object oldString532 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(532); + if (oldString532 instanceof Utf8) { + charSequence532 = (decoder).readString(((Utf8) oldString532)); + } else { + charSequence532 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(532, charSequence532); + } else { + throw new RuntimeException(("Illegal union index for 'F532': "+ unionIndex532)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex533 = (decoder.readIndex()); + if (unionIndex533 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(533, null); + } else { + if (unionIndex533 == 1) { + Utf8 charSequence533; + Object oldString533 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(533); + if (oldString533 instanceof Utf8) { + charSequence533 = (decoder).readString(((Utf8) oldString533)); + } else { + charSequence533 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(533, charSequence533); + } else { + throw new RuntimeException(("Illegal union index for 'F533': "+ unionIndex533)); + } + } + int unionIndex534 = (decoder.readIndex()); + if (unionIndex534 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(534, null); + } else { + if (unionIndex534 == 1) { + Utf8 charSequence534; + Object oldString534 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(534); + if (oldString534 instanceof Utf8) { + charSequence534 = (decoder).readString(((Utf8) oldString534)); + } else { + charSequence534 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(534, charSequence534); + } else { + throw new RuntimeException(("Illegal union index for 'F534': "+ unionIndex534)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex535 = (decoder.readIndex()); + if (unionIndex535 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(535, null); + } else { + if (unionIndex535 == 1) { + Utf8 charSequence535; + Object oldString535 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(535); + if (oldString535 instanceof Utf8) { + charSequence535 = (decoder).readString(((Utf8) oldString535)); + } else { + charSequence535 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(535, charSequence535); + } else { + throw new RuntimeException(("Illegal union index for 'F535': "+ unionIndex535)); + } + } + int unionIndex536 = (decoder.readIndex()); + if (unionIndex536 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(536, null); + } else { + if (unionIndex536 == 1) { + Utf8 charSequence536; + Object oldString536 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(536); + if (oldString536 instanceof Utf8) { + charSequence536 = (decoder).readString(((Utf8) oldString536)); + } else { + charSequence536 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(536, charSequence536); + } else { + throw new RuntimeException(("Illegal union index for 'F536': "+ unionIndex536)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex537 = (decoder.readIndex()); + if (unionIndex537 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(537, null); + } else { + if (unionIndex537 == 1) { + Utf8 charSequence537; + Object oldString537 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(537); + if (oldString537 instanceof Utf8) { + charSequence537 = (decoder).readString(((Utf8) oldString537)); + } else { + charSequence537 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(537, charSequence537); + } else { + throw new RuntimeException(("Illegal union index for 'F537': "+ unionIndex537)); + } + } + int unionIndex538 = (decoder.readIndex()); + if (unionIndex538 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(538, null); + } else { + if (unionIndex538 == 1) { + Utf8 charSequence538; + Object oldString538 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(538); + if (oldString538 instanceof Utf8) { + charSequence538 = (decoder).readString(((Utf8) oldString538)); + } else { + charSequence538 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(538, charSequence538); + } else { + throw new RuntimeException(("Illegal union index for 'F538': "+ unionIndex538)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex539 = (decoder.readIndex()); + if (unionIndex539 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(539, null); + } else { + if (unionIndex539 == 1) { + Utf8 charSequence539; + Object oldString539 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(539); + if (oldString539 instanceof Utf8) { + charSequence539 = (decoder).readString(((Utf8) oldString539)); + } else { + charSequence539 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(539, charSequence539); + } else { + throw new RuntimeException(("Illegal union index for 'F539': "+ unionIndex539)); + } + } + int unionIndex540 = (decoder.readIndex()); + if (unionIndex540 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(540, null); + } else { + if (unionIndex540 == 1) { + Utf8 charSequence540; + Object oldString540 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(540); + if (oldString540 instanceof Utf8) { + charSequence540 = (decoder).readString(((Utf8) oldString540)); + } else { + charSequence540 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(540, charSequence540); + } else { + throw new RuntimeException(("Illegal union index for 'F540': "+ unionIndex540)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex541 = (decoder.readIndex()); + if (unionIndex541 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(541, null); + } else { + if (unionIndex541 == 1) { + Utf8 charSequence541; + Object oldString541 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(541); + if (oldString541 instanceof Utf8) { + charSequence541 = (decoder).readString(((Utf8) oldString541)); + } else { + charSequence541 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(541, charSequence541); + } else { + throw new RuntimeException(("Illegal union index for 'F541': "+ unionIndex541)); + } + } + int unionIndex542 = (decoder.readIndex()); + if (unionIndex542 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(542, null); + } else { + if (unionIndex542 == 1) { + Utf8 charSequence542; + Object oldString542 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(542); + if (oldString542 instanceof Utf8) { + charSequence542 = (decoder).readString(((Utf8) oldString542)); + } else { + charSequence542 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(542, charSequence542); + } else { + throw new RuntimeException(("Illegal union index for 'F542': "+ unionIndex542)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex543 = (decoder.readIndex()); + if (unionIndex543 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(543, null); + } else { + if (unionIndex543 == 1) { + Utf8 charSequence543; + Object oldString543 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(543); + if (oldString543 instanceof Utf8) { + charSequence543 = (decoder).readString(((Utf8) oldString543)); + } else { + charSequence543 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(543, charSequence543); + } else { + throw new RuntimeException(("Illegal union index for 'F543': "+ unionIndex543)); + } + } + int unionIndex544 = (decoder.readIndex()); + if (unionIndex544 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(544, null); + } else { + if (unionIndex544 == 1) { + Utf8 charSequence544; + Object oldString544 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(544); + if (oldString544 instanceof Utf8) { + charSequence544 = (decoder).readString(((Utf8) oldString544)); + } else { + charSequence544 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(544, charSequence544); + } else { + throw new RuntimeException(("Illegal union index for 'F544': "+ unionIndex544)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex545 = (decoder.readIndex()); + if (unionIndex545 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(545, null); + } else { + if (unionIndex545 == 1) { + Utf8 charSequence545; + Object oldString545 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(545); + if (oldString545 instanceof Utf8) { + charSequence545 = (decoder).readString(((Utf8) oldString545)); + } else { + charSequence545 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(545, charSequence545); + } else { + throw new RuntimeException(("Illegal union index for 'F545': "+ unionIndex545)); + } + } + int unionIndex546 = (decoder.readIndex()); + if (unionIndex546 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(546, null); + } else { + if (unionIndex546 == 1) { + Utf8 charSequence546; + Object oldString546 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(546); + if (oldString546 instanceof Utf8) { + charSequence546 = (decoder).readString(((Utf8) oldString546)); + } else { + charSequence546 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(546, charSequence546); + } else { + throw new RuntimeException(("Illegal union index for 'F546': "+ unionIndex546)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex547 = (decoder.readIndex()); + if (unionIndex547 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(547, null); + } else { + if (unionIndex547 == 1) { + Utf8 charSequence547; + Object oldString547 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(547); + if (oldString547 instanceof Utf8) { + charSequence547 = (decoder).readString(((Utf8) oldString547)); + } else { + charSequence547 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(547, charSequence547); + } else { + throw new RuntimeException(("Illegal union index for 'F547': "+ unionIndex547)); + } + } + int unionIndex548 = (decoder.readIndex()); + if (unionIndex548 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(548, null); + } else { + if (unionIndex548 == 1) { + Utf8 charSequence548; + Object oldString548 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(548); + if (oldString548 instanceof Utf8) { + charSequence548 = (decoder).readString(((Utf8) oldString548)); + } else { + charSequence548 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(548, charSequence548); + } else { + throw new RuntimeException(("Illegal union index for 'F548': "+ unionIndex548)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex549 = (decoder.readIndex()); + if (unionIndex549 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(549, null); + } else { + if (unionIndex549 == 1) { + Utf8 charSequence549; + Object oldString549 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(549); + if (oldString549 instanceof Utf8) { + charSequence549 = (decoder).readString(((Utf8) oldString549)); + } else { + charSequence549 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(549, charSequence549); + } else { + throw new RuntimeException(("Illegal union index for 'F549': "+ unionIndex549)); + } + } + int unionIndex550 = (decoder.readIndex()); + if (unionIndex550 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(550, null); + } else { + if (unionIndex550 == 1) { + Utf8 charSequence550; + Object oldString550 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(550); + if (oldString550 instanceof Utf8) { + charSequence550 = (decoder).readString(((Utf8) oldString550)); + } else { + charSequence550 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(550, charSequence550); + } else { + throw new RuntimeException(("Illegal union index for 'F550': "+ unionIndex550)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex551 = (decoder.readIndex()); + if (unionIndex551 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(551, null); + } else { + if (unionIndex551 == 1) { + Utf8 charSequence551; + Object oldString551 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(551); + if (oldString551 instanceof Utf8) { + charSequence551 = (decoder).readString(((Utf8) oldString551)); + } else { + charSequence551 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(551, charSequence551); + } else { + throw new RuntimeException(("Illegal union index for 'F551': "+ unionIndex551)); + } + } + int unionIndex552 = (decoder.readIndex()); + if (unionIndex552 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(552, null); + } else { + if (unionIndex552 == 1) { + Utf8 charSequence552; + Object oldString552 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(552); + if (oldString552 instanceof Utf8) { + charSequence552 = (decoder).readString(((Utf8) oldString552)); + } else { + charSequence552 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(552, charSequence552); + } else { + throw new RuntimeException(("Illegal union index for 'F552': "+ unionIndex552)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex553 = (decoder.readIndex()); + if (unionIndex553 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(553, null); + } else { + if (unionIndex553 == 1) { + Utf8 charSequence553; + Object oldString553 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(553); + if (oldString553 instanceof Utf8) { + charSequence553 = (decoder).readString(((Utf8) oldString553)); + } else { + charSequence553 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(553, charSequence553); + } else { + throw new RuntimeException(("Illegal union index for 'F553': "+ unionIndex553)); + } + } + int unionIndex554 = (decoder.readIndex()); + if (unionIndex554 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(554, null); + } else { + if (unionIndex554 == 1) { + Utf8 charSequence554; + Object oldString554 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(554); + if (oldString554 instanceof Utf8) { + charSequence554 = (decoder).readString(((Utf8) oldString554)); + } else { + charSequence554 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(554, charSequence554); + } else { + throw new RuntimeException(("Illegal union index for 'F554': "+ unionIndex554)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex555 = (decoder.readIndex()); + if (unionIndex555 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(555, null); + } else { + if (unionIndex555 == 1) { + Utf8 charSequence555; + Object oldString555 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(555); + if (oldString555 instanceof Utf8) { + charSequence555 = (decoder).readString(((Utf8) oldString555)); + } else { + charSequence555 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(555, charSequence555); + } else { + throw new RuntimeException(("Illegal union index for 'F555': "+ unionIndex555)); + } + } + int unionIndex556 = (decoder.readIndex()); + if (unionIndex556 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(556, null); + } else { + if (unionIndex556 == 1) { + Utf8 charSequence556; + Object oldString556 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(556); + if (oldString556 instanceof Utf8) { + charSequence556 = (decoder).readString(((Utf8) oldString556)); + } else { + charSequence556 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(556, charSequence556); + } else { + throw new RuntimeException(("Illegal union index for 'F556': "+ unionIndex556)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex557 = (decoder.readIndex()); + if (unionIndex557 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(557, null); + } else { + if (unionIndex557 == 1) { + Utf8 charSequence557; + Object oldString557 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(557); + if (oldString557 instanceof Utf8) { + charSequence557 = (decoder).readString(((Utf8) oldString557)); + } else { + charSequence557 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(557, charSequence557); + } else { + throw new RuntimeException(("Illegal union index for 'F557': "+ unionIndex557)); + } + } + int unionIndex558 = (decoder.readIndex()); + if (unionIndex558 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(558, null); + } else { + if (unionIndex558 == 1) { + Utf8 charSequence558; + Object oldString558 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(558); + if (oldString558 instanceof Utf8) { + charSequence558 = (decoder).readString(((Utf8) oldString558)); + } else { + charSequence558 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(558, charSequence558); + } else { + throw new RuntimeException(("Illegal union index for 'F558': "+ unionIndex558)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex559 = (decoder.readIndex()); + if (unionIndex559 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(559, null); + } else { + if (unionIndex559 == 1) { + Utf8 charSequence559; + Object oldString559 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(559); + if (oldString559 instanceof Utf8) { + charSequence559 = (decoder).readString(((Utf8) oldString559)); + } else { + charSequence559 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(559, charSequence559); + } else { + throw new RuntimeException(("Illegal union index for 'F559': "+ unionIndex559)); + } + } + int unionIndex560 = (decoder.readIndex()); + if (unionIndex560 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(560, null); + } else { + if (unionIndex560 == 1) { + Utf8 charSequence560; + Object oldString560 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(560); + if (oldString560 instanceof Utf8) { + charSequence560 = (decoder).readString(((Utf8) oldString560)); + } else { + charSequence560 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(560, charSequence560); + } else { + throw new RuntimeException(("Illegal union index for 'F560': "+ unionIndex560)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex561 = (decoder.readIndex()); + if (unionIndex561 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(561, null); + } else { + if (unionIndex561 == 1) { + Utf8 charSequence561; + Object oldString561 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(561); + if (oldString561 instanceof Utf8) { + charSequence561 = (decoder).readString(((Utf8) oldString561)); + } else { + charSequence561 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(561, charSequence561); + } else { + throw new RuntimeException(("Illegal union index for 'F561': "+ unionIndex561)); + } + } + int unionIndex562 = (decoder.readIndex()); + if (unionIndex562 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(562, null); + } else { + if (unionIndex562 == 1) { + Utf8 charSequence562; + Object oldString562 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(562); + if (oldString562 instanceof Utf8) { + charSequence562 = (decoder).readString(((Utf8) oldString562)); + } else { + charSequence562 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(562, charSequence562); + } else { + throw new RuntimeException(("Illegal union index for 'F562': "+ unionIndex562)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex563 = (decoder.readIndex()); + if (unionIndex563 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(563, null); + } else { + if (unionIndex563 == 1) { + Utf8 charSequence563; + Object oldString563 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(563); + if (oldString563 instanceof Utf8) { + charSequence563 = (decoder).readString(((Utf8) oldString563)); + } else { + charSequence563 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(563, charSequence563); + } else { + throw new RuntimeException(("Illegal union index for 'F563': "+ unionIndex563)); + } + } + int unionIndex564 = (decoder.readIndex()); + if (unionIndex564 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(564, null); + } else { + if (unionIndex564 == 1) { + Utf8 charSequence564; + Object oldString564 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(564); + if (oldString564 instanceof Utf8) { + charSequence564 = (decoder).readString(((Utf8) oldString564)); + } else { + charSequence564 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(564, charSequence564); + } else { + throw new RuntimeException(("Illegal union index for 'F564': "+ unionIndex564)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex565 = (decoder.readIndex()); + if (unionIndex565 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(565, null); + } else { + if (unionIndex565 == 1) { + Utf8 charSequence565; + Object oldString565 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(565); + if (oldString565 instanceof Utf8) { + charSequence565 = (decoder).readString(((Utf8) oldString565)); + } else { + charSequence565 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(565, charSequence565); + } else { + throw new RuntimeException(("Illegal union index for 'F565': "+ unionIndex565)); + } + } + int unionIndex566 = (decoder.readIndex()); + if (unionIndex566 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(566, null); + } else { + if (unionIndex566 == 1) { + Utf8 charSequence566; + Object oldString566 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(566); + if (oldString566 instanceof Utf8) { + charSequence566 = (decoder).readString(((Utf8) oldString566)); + } else { + charSequence566 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(566, charSequence566); + } else { + throw new RuntimeException(("Illegal union index for 'F566': "+ unionIndex566)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex567 = (decoder.readIndex()); + if (unionIndex567 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(567, null); + } else { + if (unionIndex567 == 1) { + Utf8 charSequence567; + Object oldString567 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(567); + if (oldString567 instanceof Utf8) { + charSequence567 = (decoder).readString(((Utf8) oldString567)); + } else { + charSequence567 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(567, charSequence567); + } else { + throw new RuntimeException(("Illegal union index for 'F567': "+ unionIndex567)); + } + } + int unionIndex568 = (decoder.readIndex()); + if (unionIndex568 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(568, null); + } else { + if (unionIndex568 == 1) { + Utf8 charSequence568; + Object oldString568 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(568); + if (oldString568 instanceof Utf8) { + charSequence568 = (decoder).readString(((Utf8) oldString568)); + } else { + charSequence568 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(568, charSequence568); + } else { + throw new RuntimeException(("Illegal union index for 'F568': "+ unionIndex568)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex569 = (decoder.readIndex()); + if (unionIndex569 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(569, null); + } else { + if (unionIndex569 == 1) { + Utf8 charSequence569; + Object oldString569 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(569); + if (oldString569 instanceof Utf8) { + charSequence569 = (decoder).readString(((Utf8) oldString569)); + } else { + charSequence569 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(569, charSequence569); + } else { + throw new RuntimeException(("Illegal union index for 'F569': "+ unionIndex569)); + } + } + int unionIndex570 = (decoder.readIndex()); + if (unionIndex570 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(570, null); + } else { + if (unionIndex570 == 1) { + Utf8 charSequence570; + Object oldString570 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(570); + if (oldString570 instanceof Utf8) { + charSequence570 = (decoder).readString(((Utf8) oldString570)); + } else { + charSequence570 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(570, charSequence570); + } else { + throw new RuntimeException(("Illegal union index for 'F570': "+ unionIndex570)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex571 = (decoder.readIndex()); + if (unionIndex571 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(571, null); + } else { + if (unionIndex571 == 1) { + Utf8 charSequence571; + Object oldString571 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(571); + if (oldString571 instanceof Utf8) { + charSequence571 = (decoder).readString(((Utf8) oldString571)); + } else { + charSequence571 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(571, charSequence571); + } else { + throw new RuntimeException(("Illegal union index for 'F571': "+ unionIndex571)); + } + } + int unionIndex572 = (decoder.readIndex()); + if (unionIndex572 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(572, null); + } else { + if (unionIndex572 == 1) { + Utf8 charSequence572; + Object oldString572 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(572); + if (oldString572 instanceof Utf8) { + charSequence572 = (decoder).readString(((Utf8) oldString572)); + } else { + charSequence572 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(572, charSequence572); + } else { + throw new RuntimeException(("Illegal union index for 'F572': "+ unionIndex572)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex573 = (decoder.readIndex()); + if (unionIndex573 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(573, null); + } else { + if (unionIndex573 == 1) { + Utf8 charSequence573; + Object oldString573 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(573); + if (oldString573 instanceof Utf8) { + charSequence573 = (decoder).readString(((Utf8) oldString573)); + } else { + charSequence573 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(573, charSequence573); + } else { + throw new RuntimeException(("Illegal union index for 'F573': "+ unionIndex573)); + } + } + int unionIndex574 = (decoder.readIndex()); + if (unionIndex574 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(574, null); + } else { + if (unionIndex574 == 1) { + Utf8 charSequence574; + Object oldString574 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(574); + if (oldString574 instanceof Utf8) { + charSequence574 = (decoder).readString(((Utf8) oldString574)); + } else { + charSequence574 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(574, charSequence574); + } else { + throw new RuntimeException(("Illegal union index for 'F574': "+ unionIndex574)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex575 = (decoder.readIndex()); + if (unionIndex575 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(575, null); + } else { + if (unionIndex575 == 1) { + Utf8 charSequence575; + Object oldString575 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(575); + if (oldString575 instanceof Utf8) { + charSequence575 = (decoder).readString(((Utf8) oldString575)); + } else { + charSequence575 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(575, charSequence575); + } else { + throw new RuntimeException(("Illegal union index for 'F575': "+ unionIndex575)); + } + } + int unionIndex576 = (decoder.readIndex()); + if (unionIndex576 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(576, null); + } else { + if (unionIndex576 == 1) { + Utf8 charSequence576; + Object oldString576 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(576); + if (oldString576 instanceof Utf8) { + charSequence576 = (decoder).readString(((Utf8) oldString576)); + } else { + charSequence576 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(576, charSequence576); + } else { + throw new RuntimeException(("Illegal union index for 'F576': "+ unionIndex576)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex577 = (decoder.readIndex()); + if (unionIndex577 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(577, null); + } else { + if (unionIndex577 == 1) { + Utf8 charSequence577; + Object oldString577 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(577); + if (oldString577 instanceof Utf8) { + charSequence577 = (decoder).readString(((Utf8) oldString577)); + } else { + charSequence577 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(577, charSequence577); + } else { + throw new RuntimeException(("Illegal union index for 'F577': "+ unionIndex577)); + } + } + int unionIndex578 = (decoder.readIndex()); + if (unionIndex578 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(578, null); + } else { + if (unionIndex578 == 1) { + Utf8 charSequence578; + Object oldString578 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(578); + if (oldString578 instanceof Utf8) { + charSequence578 = (decoder).readString(((Utf8) oldString578)); + } else { + charSequence578 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(578, charSequence578); + } else { + throw new RuntimeException(("Illegal union index for 'F578': "+ unionIndex578)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex579 = (decoder.readIndex()); + if (unionIndex579 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(579, null); + } else { + if (unionIndex579 == 1) { + Utf8 charSequence579; + Object oldString579 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(579); + if (oldString579 instanceof Utf8) { + charSequence579 = (decoder).readString(((Utf8) oldString579)); + } else { + charSequence579 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(579, charSequence579); + } else { + throw new RuntimeException(("Illegal union index for 'F579': "+ unionIndex579)); + } + } + int unionIndex580 = (decoder.readIndex()); + if (unionIndex580 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(580, null); + } else { + if (unionIndex580 == 1) { + Utf8 charSequence580; + Object oldString580 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(580); + if (oldString580 instanceof Utf8) { + charSequence580 = (decoder).readString(((Utf8) oldString580)); + } else { + charSequence580 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(580, charSequence580); + } else { + throw new RuntimeException(("Illegal union index for 'F580': "+ unionIndex580)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex581 = (decoder.readIndex()); + if (unionIndex581 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(581, null); + } else { + if (unionIndex581 == 1) { + Utf8 charSequence581; + Object oldString581 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(581); + if (oldString581 instanceof Utf8) { + charSequence581 = (decoder).readString(((Utf8) oldString581)); + } else { + charSequence581 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(581, charSequence581); + } else { + throw new RuntimeException(("Illegal union index for 'F581': "+ unionIndex581)); + } + } + int unionIndex582 = (decoder.readIndex()); + if (unionIndex582 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(582, null); + } else { + if (unionIndex582 == 1) { + Utf8 charSequence582; + Object oldString582 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(582); + if (oldString582 instanceof Utf8) { + charSequence582 = (decoder).readString(((Utf8) oldString582)); + } else { + charSequence582 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(582, charSequence582); + } else { + throw new RuntimeException(("Illegal union index for 'F582': "+ unionIndex582)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex583 = (decoder.readIndex()); + if (unionIndex583 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(583, null); + } else { + if (unionIndex583 == 1) { + Utf8 charSequence583; + Object oldString583 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(583); + if (oldString583 instanceof Utf8) { + charSequence583 = (decoder).readString(((Utf8) oldString583)); + } else { + charSequence583 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(583, charSequence583); + } else { + throw new RuntimeException(("Illegal union index for 'F583': "+ unionIndex583)); + } + } + int unionIndex584 = (decoder.readIndex()); + if (unionIndex584 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(584, null); + } else { + if (unionIndex584 == 1) { + Utf8 charSequence584; + Object oldString584 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(584); + if (oldString584 instanceof Utf8) { + charSequence584 = (decoder).readString(((Utf8) oldString584)); + } else { + charSequence584 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(584, charSequence584); + } else { + throw new RuntimeException(("Illegal union index for 'F584': "+ unionIndex584)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex585 = (decoder.readIndex()); + if (unionIndex585 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(585, null); + } else { + if (unionIndex585 == 1) { + Utf8 charSequence585; + Object oldString585 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(585); + if (oldString585 instanceof Utf8) { + charSequence585 = (decoder).readString(((Utf8) oldString585)); + } else { + charSequence585 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(585, charSequence585); + } else { + throw new RuntimeException(("Illegal union index for 'F585': "+ unionIndex585)); + } + } + int unionIndex586 = (decoder.readIndex()); + if (unionIndex586 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(586, null); + } else { + if (unionIndex586 == 1) { + Utf8 charSequence586; + Object oldString586 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(586); + if (oldString586 instanceof Utf8) { + charSequence586 = (decoder).readString(((Utf8) oldString586)); + } else { + charSequence586 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(586, charSequence586); + } else { + throw new RuntimeException(("Illegal union index for 'F586': "+ unionIndex586)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex587 = (decoder.readIndex()); + if (unionIndex587 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(587, null); + } else { + if (unionIndex587 == 1) { + Utf8 charSequence587; + Object oldString587 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(587); + if (oldString587 instanceof Utf8) { + charSequence587 = (decoder).readString(((Utf8) oldString587)); + } else { + charSequence587 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(587, charSequence587); + } else { + throw new RuntimeException(("Illegal union index for 'F587': "+ unionIndex587)); + } + } + int unionIndex588 = (decoder.readIndex()); + if (unionIndex588 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(588, null); + } else { + if (unionIndex588 == 1) { + Utf8 charSequence588; + Object oldString588 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(588); + if (oldString588 instanceof Utf8) { + charSequence588 = (decoder).readString(((Utf8) oldString588)); + } else { + charSequence588 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(588, charSequence588); + } else { + throw new RuntimeException(("Illegal union index for 'F588': "+ unionIndex588)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex589 = (decoder.readIndex()); + if (unionIndex589 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(589, null); + } else { + if (unionIndex589 == 1) { + Utf8 charSequence589; + Object oldString589 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(589); + if (oldString589 instanceof Utf8) { + charSequence589 = (decoder).readString(((Utf8) oldString589)); + } else { + charSequence589 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(589, charSequence589); + } else { + throw new RuntimeException(("Illegal union index for 'F589': "+ unionIndex589)); + } + } + int unionIndex590 = (decoder.readIndex()); + if (unionIndex590 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(590, null); + } else { + if (unionIndex590 == 1) { + Utf8 charSequence590; + Object oldString590 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(590); + if (oldString590 instanceof Utf8) { + charSequence590 = (decoder).readString(((Utf8) oldString590)); + } else { + charSequence590 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(590, charSequence590); + } else { + throw new RuntimeException(("Illegal union index for 'F590': "+ unionIndex590)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex591 = (decoder.readIndex()); + if (unionIndex591 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(591, null); + } else { + if (unionIndex591 == 1) { + Utf8 charSequence591; + Object oldString591 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(591); + if (oldString591 instanceof Utf8) { + charSequence591 = (decoder).readString(((Utf8) oldString591)); + } else { + charSequence591 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(591, charSequence591); + } else { + throw new RuntimeException(("Illegal union index for 'F591': "+ unionIndex591)); + } + } + int unionIndex592 = (decoder.readIndex()); + if (unionIndex592 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(592, null); + } else { + if (unionIndex592 == 1) { + Utf8 charSequence592; + Object oldString592 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(592); + if (oldString592 instanceof Utf8) { + charSequence592 = (decoder).readString(((Utf8) oldString592)); + } else { + charSequence592 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(592, charSequence592); + } else { + throw new RuntimeException(("Illegal union index for 'F592': "+ unionIndex592)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex593 = (decoder.readIndex()); + if (unionIndex593 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(593, null); + } else { + if (unionIndex593 == 1) { + Utf8 charSequence593; + Object oldString593 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(593); + if (oldString593 instanceof Utf8) { + charSequence593 = (decoder).readString(((Utf8) oldString593)); + } else { + charSequence593 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(593, charSequence593); + } else { + throw new RuntimeException(("Illegal union index for 'F593': "+ unionIndex593)); + } + } + int unionIndex594 = (decoder.readIndex()); + if (unionIndex594 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(594, null); + } else { + if (unionIndex594 == 1) { + Utf8 charSequence594; + Object oldString594 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(594); + if (oldString594 instanceof Utf8) { + charSequence594 = (decoder).readString(((Utf8) oldString594)); + } else { + charSequence594 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(594, charSequence594); + } else { + throw new RuntimeException(("Illegal union index for 'F594': "+ unionIndex594)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex595 = (decoder.readIndex()); + if (unionIndex595 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(595, null); + } else { + if (unionIndex595 == 1) { + Utf8 charSequence595; + Object oldString595 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(595); + if (oldString595 instanceof Utf8) { + charSequence595 = (decoder).readString(((Utf8) oldString595)); + } else { + charSequence595 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(595, charSequence595); + } else { + throw new RuntimeException(("Illegal union index for 'F595': "+ unionIndex595)); + } + } + int unionIndex596 = (decoder.readIndex()); + if (unionIndex596 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(596, null); + } else { + if (unionIndex596 == 1) { + Utf8 charSequence596; + Object oldString596 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(596); + if (oldString596 instanceof Utf8) { + charSequence596 = (decoder).readString(((Utf8) oldString596)); + } else { + charSequence596 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(596, charSequence596); + } else { + throw new RuntimeException(("Illegal union index for 'F596': "+ unionIndex596)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex597 = (decoder.readIndex()); + if (unionIndex597 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(597, null); + } else { + if (unionIndex597 == 1) { + Utf8 charSequence597; + Object oldString597 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(597); + if (oldString597 instanceof Utf8) { + charSequence597 = (decoder).readString(((Utf8) oldString597)); + } else { + charSequence597 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(597, charSequence597); + } else { + throw new RuntimeException(("Illegal union index for 'F597': "+ unionIndex597)); + } + } + int unionIndex598 = (decoder.readIndex()); + if (unionIndex598 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(598, null); + } else { + if (unionIndex598 == 1) { + Utf8 charSequence598; + Object oldString598 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(598); + if (oldString598 instanceof Utf8) { + charSequence598 = (decoder).readString(((Utf8) oldString598)); + } else { + charSequence598 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(598, charSequence598); + } else { + throw new RuntimeException(("Illegal union index for 'F598': "+ unionIndex598)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex599 = (decoder.readIndex()); + if (unionIndex599 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(599, null); + } else { + if (unionIndex599 == 1) { + Utf8 charSequence599; + Object oldString599 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(599); + if (oldString599 instanceof Utf8) { + charSequence599 = (decoder).readString(((Utf8) oldString599)); + } else { + charSequence599 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(599, charSequence599); + } else { + throw new RuntimeException(("Illegal union index for 'F599': "+ unionIndex599)); + } + } + int unionIndex600 = (decoder.readIndex()); + if (unionIndex600 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(600, null); + } else { + if (unionIndex600 == 1) { + Utf8 charSequence600; + Object oldString600 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(600); + if (oldString600 instanceof Utf8) { + charSequence600 = (decoder).readString(((Utf8) oldString600)); + } else { + charSequence600 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(600, charSequence600); + } else { + throw new RuntimeException(("Illegal union index for 'F600': "+ unionIndex600)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex601 = (decoder.readIndex()); + if (unionIndex601 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(601, null); + } else { + if (unionIndex601 == 1) { + Utf8 charSequence601; + Object oldString601 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(601); + if (oldString601 instanceof Utf8) { + charSequence601 = (decoder).readString(((Utf8) oldString601)); + } else { + charSequence601 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(601, charSequence601); + } else { + throw new RuntimeException(("Illegal union index for 'F601': "+ unionIndex601)); + } + } + int unionIndex602 = (decoder.readIndex()); + if (unionIndex602 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(602, null); + } else { + if (unionIndex602 == 1) { + Utf8 charSequence602; + Object oldString602 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(602); + if (oldString602 instanceof Utf8) { + charSequence602 = (decoder).readString(((Utf8) oldString602)); + } else { + charSequence602 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(602, charSequence602); + } else { + throw new RuntimeException(("Illegal union index for 'F602': "+ unionIndex602)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex603 = (decoder.readIndex()); + if (unionIndex603 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(603, null); + } else { + if (unionIndex603 == 1) { + Utf8 charSequence603; + Object oldString603 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(603); + if (oldString603 instanceof Utf8) { + charSequence603 = (decoder).readString(((Utf8) oldString603)); + } else { + charSequence603 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(603, charSequence603); + } else { + throw new RuntimeException(("Illegal union index for 'F603': "+ unionIndex603)); + } + } + int unionIndex604 = (decoder.readIndex()); + if (unionIndex604 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(604, null); + } else { + if (unionIndex604 == 1) { + Utf8 charSequence604; + Object oldString604 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(604); + if (oldString604 instanceof Utf8) { + charSequence604 = (decoder).readString(((Utf8) oldString604)); + } else { + charSequence604 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(604, charSequence604); + } else { + throw new RuntimeException(("Illegal union index for 'F604': "+ unionIndex604)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex605 = (decoder.readIndex()); + if (unionIndex605 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(605, null); + } else { + if (unionIndex605 == 1) { + Utf8 charSequence605; + Object oldString605 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(605); + if (oldString605 instanceof Utf8) { + charSequence605 = (decoder).readString(((Utf8) oldString605)); + } else { + charSequence605 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(605, charSequence605); + } else { + throw new RuntimeException(("Illegal union index for 'F605': "+ unionIndex605)); + } + } + int unionIndex606 = (decoder.readIndex()); + if (unionIndex606 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(606, null); + } else { + if (unionIndex606 == 1) { + Utf8 charSequence606; + Object oldString606 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(606); + if (oldString606 instanceof Utf8) { + charSequence606 = (decoder).readString(((Utf8) oldString606)); + } else { + charSequence606 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(606, charSequence606); + } else { + throw new RuntimeException(("Illegal union index for 'F606': "+ unionIndex606)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex607 = (decoder.readIndex()); + if (unionIndex607 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(607, null); + } else { + if (unionIndex607 == 1) { + Utf8 charSequence607; + Object oldString607 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(607); + if (oldString607 instanceof Utf8) { + charSequence607 = (decoder).readString(((Utf8) oldString607)); + } else { + charSequence607 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(607, charSequence607); + } else { + throw new RuntimeException(("Illegal union index for 'F607': "+ unionIndex607)); + } + } + int unionIndex608 = (decoder.readIndex()); + if (unionIndex608 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(608, null); + } else { + if (unionIndex608 == 1) { + Utf8 charSequence608; + Object oldString608 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(608); + if (oldString608 instanceof Utf8) { + charSequence608 = (decoder).readString(((Utf8) oldString608)); + } else { + charSequence608 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(608, charSequence608); + } else { + throw new RuntimeException(("Illegal union index for 'F608': "+ unionIndex608)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex609 = (decoder.readIndex()); + if (unionIndex609 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(609, null); + } else { + if (unionIndex609 == 1) { + Utf8 charSequence609; + Object oldString609 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(609); + if (oldString609 instanceof Utf8) { + charSequence609 = (decoder).readString(((Utf8) oldString609)); + } else { + charSequence609 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(609, charSequence609); + } else { + throw new RuntimeException(("Illegal union index for 'F609': "+ unionIndex609)); + } + } + int unionIndex610 = (decoder.readIndex()); + if (unionIndex610 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(610, null); + } else { + if (unionIndex610 == 1) { + Utf8 charSequence610; + Object oldString610 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(610); + if (oldString610 instanceof Utf8) { + charSequence610 = (decoder).readString(((Utf8) oldString610)); + } else { + charSequence610 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(610, charSequence610); + } else { + throw new RuntimeException(("Illegal union index for 'F610': "+ unionIndex610)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex611 = (decoder.readIndex()); + if (unionIndex611 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(611, null); + } else { + if (unionIndex611 == 1) { + Utf8 charSequence611; + Object oldString611 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(611); + if (oldString611 instanceof Utf8) { + charSequence611 = (decoder).readString(((Utf8) oldString611)); + } else { + charSequence611 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(611, charSequence611); + } else { + throw new RuntimeException(("Illegal union index for 'F611': "+ unionIndex611)); + } + } + int unionIndex612 = (decoder.readIndex()); + if (unionIndex612 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(612, null); + } else { + if (unionIndex612 == 1) { + Utf8 charSequence612; + Object oldString612 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(612); + if (oldString612 instanceof Utf8) { + charSequence612 = (decoder).readString(((Utf8) oldString612)); + } else { + charSequence612 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(612, charSequence612); + } else { + throw new RuntimeException(("Illegal union index for 'F612': "+ unionIndex612)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex613 = (decoder.readIndex()); + if (unionIndex613 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(613, null); + } else { + if (unionIndex613 == 1) { + Utf8 charSequence613; + Object oldString613 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(613); + if (oldString613 instanceof Utf8) { + charSequence613 = (decoder).readString(((Utf8) oldString613)); + } else { + charSequence613 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(613, charSequence613); + } else { + throw new RuntimeException(("Illegal union index for 'F613': "+ unionIndex613)); + } + } + int unionIndex614 = (decoder.readIndex()); + if (unionIndex614 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(614, null); + } else { + if (unionIndex614 == 1) { + Utf8 charSequence614; + Object oldString614 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(614); + if (oldString614 instanceof Utf8) { + charSequence614 = (decoder).readString(((Utf8) oldString614)); + } else { + charSequence614 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(614, charSequence614); + } else { + throw new RuntimeException(("Illegal union index for 'F614': "+ unionIndex614)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex615 = (decoder.readIndex()); + if (unionIndex615 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(615, null); + } else { + if (unionIndex615 == 1) { + Utf8 charSequence615; + Object oldString615 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(615); + if (oldString615 instanceof Utf8) { + charSequence615 = (decoder).readString(((Utf8) oldString615)); + } else { + charSequence615 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(615, charSequence615); + } else { + throw new RuntimeException(("Illegal union index for 'F615': "+ unionIndex615)); + } + } + int unionIndex616 = (decoder.readIndex()); + if (unionIndex616 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(616, null); + } else { + if (unionIndex616 == 1) { + Utf8 charSequence616; + Object oldString616 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(616); + if (oldString616 instanceof Utf8) { + charSequence616 = (decoder).readString(((Utf8) oldString616)); + } else { + charSequence616 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(616, charSequence616); + } else { + throw new RuntimeException(("Illegal union index for 'F616': "+ unionIndex616)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex617 = (decoder.readIndex()); + if (unionIndex617 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(617, null); + } else { + if (unionIndex617 == 1) { + Utf8 charSequence617; + Object oldString617 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(617); + if (oldString617 instanceof Utf8) { + charSequence617 = (decoder).readString(((Utf8) oldString617)); + } else { + charSequence617 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(617, charSequence617); + } else { + throw new RuntimeException(("Illegal union index for 'F617': "+ unionIndex617)); + } + } + int unionIndex618 = (decoder.readIndex()); + if (unionIndex618 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(618, null); + } else { + if (unionIndex618 == 1) { + Utf8 charSequence618; + Object oldString618 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(618); + if (oldString618 instanceof Utf8) { + charSequence618 = (decoder).readString(((Utf8) oldString618)); + } else { + charSequence618 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(618, charSequence618); + } else { + throw new RuntimeException(("Illegal union index for 'F618': "+ unionIndex618)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex619 = (decoder.readIndex()); + if (unionIndex619 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(619, null); + } else { + if (unionIndex619 == 1) { + Utf8 charSequence619; + Object oldString619 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(619); + if (oldString619 instanceof Utf8) { + charSequence619 = (decoder).readString(((Utf8) oldString619)); + } else { + charSequence619 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(619, charSequence619); + } else { + throw new RuntimeException(("Illegal union index for 'F619': "+ unionIndex619)); + } + } + int unionIndex620 = (decoder.readIndex()); + if (unionIndex620 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(620, null); + } else { + if (unionIndex620 == 1) { + Utf8 charSequence620; + Object oldString620 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(620); + if (oldString620 instanceof Utf8) { + charSequence620 = (decoder).readString(((Utf8) oldString620)); + } else { + charSequence620 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(620, charSequence620); + } else { + throw new RuntimeException(("Illegal union index for 'F620': "+ unionIndex620)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex621 = (decoder.readIndex()); + if (unionIndex621 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(621, null); + } else { + if (unionIndex621 == 1) { + Utf8 charSequence621; + Object oldString621 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(621); + if (oldString621 instanceof Utf8) { + charSequence621 = (decoder).readString(((Utf8) oldString621)); + } else { + charSequence621 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(621, charSequence621); + } else { + throw new RuntimeException(("Illegal union index for 'F621': "+ unionIndex621)); + } + } + int unionIndex622 = (decoder.readIndex()); + if (unionIndex622 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(622, null); + } else { + if (unionIndex622 == 1) { + Utf8 charSequence622; + Object oldString622 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(622); + if (oldString622 instanceof Utf8) { + charSequence622 = (decoder).readString(((Utf8) oldString622)); + } else { + charSequence622 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(622, charSequence622); + } else { + throw new RuntimeException(("Illegal union index for 'F622': "+ unionIndex622)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex623 = (decoder.readIndex()); + if (unionIndex623 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(623, null); + } else { + if (unionIndex623 == 1) { + Utf8 charSequence623; + Object oldString623 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(623); + if (oldString623 instanceof Utf8) { + charSequence623 = (decoder).readString(((Utf8) oldString623)); + } else { + charSequence623 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(623, charSequence623); + } else { + throw new RuntimeException(("Illegal union index for 'F623': "+ unionIndex623)); + } + } + int unionIndex624 = (decoder.readIndex()); + if (unionIndex624 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(624, null); + } else { + if (unionIndex624 == 1) { + Utf8 charSequence624; + Object oldString624 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(624); + if (oldString624 instanceof Utf8) { + charSequence624 = (decoder).readString(((Utf8) oldString624)); + } else { + charSequence624 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(624, charSequence624); + } else { + throw new RuntimeException(("Illegal union index for 'F624': "+ unionIndex624)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex625 = (decoder.readIndex()); + if (unionIndex625 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(625, null); + } else { + if (unionIndex625 == 1) { + Utf8 charSequence625; + Object oldString625 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(625); + if (oldString625 instanceof Utf8) { + charSequence625 = (decoder).readString(((Utf8) oldString625)); + } else { + charSequence625 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(625, charSequence625); + } else { + throw new RuntimeException(("Illegal union index for 'F625': "+ unionIndex625)); + } + } + int unionIndex626 = (decoder.readIndex()); + if (unionIndex626 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(626, null); + } else { + if (unionIndex626 == 1) { + Utf8 charSequence626; + Object oldString626 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(626); + if (oldString626 instanceof Utf8) { + charSequence626 = (decoder).readString(((Utf8) oldString626)); + } else { + charSequence626 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(626, charSequence626); + } else { + throw new RuntimeException(("Illegal union index for 'F626': "+ unionIndex626)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex627 = (decoder.readIndex()); + if (unionIndex627 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(627, null); + } else { + if (unionIndex627 == 1) { + Utf8 charSequence627; + Object oldString627 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(627); + if (oldString627 instanceof Utf8) { + charSequence627 = (decoder).readString(((Utf8) oldString627)); + } else { + charSequence627 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(627, charSequence627); + } else { + throw new RuntimeException(("Illegal union index for 'F627': "+ unionIndex627)); + } + } + int unionIndex628 = (decoder.readIndex()); + if (unionIndex628 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(628, null); + } else { + if (unionIndex628 == 1) { + Utf8 charSequence628; + Object oldString628 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(628); + if (oldString628 instanceof Utf8) { + charSequence628 = (decoder).readString(((Utf8) oldString628)); + } else { + charSequence628 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(628, charSequence628); + } else { + throw new RuntimeException(("Illegal union index for 'F628': "+ unionIndex628)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex629 = (decoder.readIndex()); + if (unionIndex629 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(629, null); + } else { + if (unionIndex629 == 1) { + Utf8 charSequence629; + Object oldString629 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(629); + if (oldString629 instanceof Utf8) { + charSequence629 = (decoder).readString(((Utf8) oldString629)); + } else { + charSequence629 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(629, charSequence629); + } else { + throw new RuntimeException(("Illegal union index for 'F629': "+ unionIndex629)); + } + } + int unionIndex630 = (decoder.readIndex()); + if (unionIndex630 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(630, null); + } else { + if (unionIndex630 == 1) { + Utf8 charSequence630; + Object oldString630 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(630); + if (oldString630 instanceof Utf8) { + charSequence630 = (decoder).readString(((Utf8) oldString630)); + } else { + charSequence630 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(630, charSequence630); + } else { + throw new RuntimeException(("Illegal union index for 'F630': "+ unionIndex630)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex631 = (decoder.readIndex()); + if (unionIndex631 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(631, null); + } else { + if (unionIndex631 == 1) { + Utf8 charSequence631; + Object oldString631 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(631); + if (oldString631 instanceof Utf8) { + charSequence631 = (decoder).readString(((Utf8) oldString631)); + } else { + charSequence631 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(631, charSequence631); + } else { + throw new RuntimeException(("Illegal union index for 'F631': "+ unionIndex631)); + } + } + int unionIndex632 = (decoder.readIndex()); + if (unionIndex632 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(632, null); + } else { + if (unionIndex632 == 1) { + Utf8 charSequence632; + Object oldString632 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(632); + if (oldString632 instanceof Utf8) { + charSequence632 = (decoder).readString(((Utf8) oldString632)); + } else { + charSequence632 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(632, charSequence632); + } else { + throw new RuntimeException(("Illegal union index for 'F632': "+ unionIndex632)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex633 = (decoder.readIndex()); + if (unionIndex633 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(633, null); + } else { + if (unionIndex633 == 1) { + Utf8 charSequence633; + Object oldString633 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(633); + if (oldString633 instanceof Utf8) { + charSequence633 = (decoder).readString(((Utf8) oldString633)); + } else { + charSequence633 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(633, charSequence633); + } else { + throw new RuntimeException(("Illegal union index for 'F633': "+ unionIndex633)); + } + } + int unionIndex634 = (decoder.readIndex()); + if (unionIndex634 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(634, null); + } else { + if (unionIndex634 == 1) { + Utf8 charSequence634; + Object oldString634 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(634); + if (oldString634 instanceof Utf8) { + charSequence634 = (decoder).readString(((Utf8) oldString634)); + } else { + charSequence634 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(634, charSequence634); + } else { + throw new RuntimeException(("Illegal union index for 'F634': "+ unionIndex634)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex635 = (decoder.readIndex()); + if (unionIndex635 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(635, null); + } else { + if (unionIndex635 == 1) { + Utf8 charSequence635; + Object oldString635 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(635); + if (oldString635 instanceof Utf8) { + charSequence635 = (decoder).readString(((Utf8) oldString635)); + } else { + charSequence635 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(635, charSequence635); + } else { + throw new RuntimeException(("Illegal union index for 'F635': "+ unionIndex635)); + } + } + int unionIndex636 = (decoder.readIndex()); + if (unionIndex636 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(636, null); + } else { + if (unionIndex636 == 1) { + Utf8 charSequence636; + Object oldString636 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(636); + if (oldString636 instanceof Utf8) { + charSequence636 = (decoder).readString(((Utf8) oldString636)); + } else { + charSequence636 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(636, charSequence636); + } else { + throw new RuntimeException(("Illegal union index for 'F636': "+ unionIndex636)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex637 = (decoder.readIndex()); + if (unionIndex637 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(637, null); + } else { + if (unionIndex637 == 1) { + Utf8 charSequence637; + Object oldString637 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(637); + if (oldString637 instanceof Utf8) { + charSequence637 = (decoder).readString(((Utf8) oldString637)); + } else { + charSequence637 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(637, charSequence637); + } else { + throw new RuntimeException(("Illegal union index for 'F637': "+ unionIndex637)); + } + } + int unionIndex638 = (decoder.readIndex()); + if (unionIndex638 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(638, null); + } else { + if (unionIndex638 == 1) { + Utf8 charSequence638; + Object oldString638 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(638); + if (oldString638 instanceof Utf8) { + charSequence638 = (decoder).readString(((Utf8) oldString638)); + } else { + charSequence638 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(638, charSequence638); + } else { + throw new RuntimeException(("Illegal union index for 'F638': "+ unionIndex638)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex639 = (decoder.readIndex()); + if (unionIndex639 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(639, null); + } else { + if (unionIndex639 == 1) { + Utf8 charSequence639; + Object oldString639 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(639); + if (oldString639 instanceof Utf8) { + charSequence639 = (decoder).readString(((Utf8) oldString639)); + } else { + charSequence639 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(639, charSequence639); + } else { + throw new RuntimeException(("Illegal union index for 'F639': "+ unionIndex639)); + } + } + int unionIndex640 = (decoder.readIndex()); + if (unionIndex640 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(640, null); + } else { + if (unionIndex640 == 1) { + Utf8 charSequence640; + Object oldString640 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(640); + if (oldString640 instanceof Utf8) { + charSequence640 = (decoder).readString(((Utf8) oldString640)); + } else { + charSequence640 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(640, charSequence640); + } else { + throw new RuntimeException(("Illegal union index for 'F640': "+ unionIndex640)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex641 = (decoder.readIndex()); + if (unionIndex641 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(641, null); + } else { + if (unionIndex641 == 1) { + Utf8 charSequence641; + Object oldString641 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(641); + if (oldString641 instanceof Utf8) { + charSequence641 = (decoder).readString(((Utf8) oldString641)); + } else { + charSequence641 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(641, charSequence641); + } else { + throw new RuntimeException(("Illegal union index for 'F641': "+ unionIndex641)); + } + } + int unionIndex642 = (decoder.readIndex()); + if (unionIndex642 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(642, null); + } else { + if (unionIndex642 == 1) { + Utf8 charSequence642; + Object oldString642 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(642); + if (oldString642 instanceof Utf8) { + charSequence642 = (decoder).readString(((Utf8) oldString642)); + } else { + charSequence642 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(642, charSequence642); + } else { + throw new RuntimeException(("Illegal union index for 'F642': "+ unionIndex642)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex643 = (decoder.readIndex()); + if (unionIndex643 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(643, null); + } else { + if (unionIndex643 == 1) { + Utf8 charSequence643; + Object oldString643 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(643); + if (oldString643 instanceof Utf8) { + charSequence643 = (decoder).readString(((Utf8) oldString643)); + } else { + charSequence643 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(643, charSequence643); + } else { + throw new RuntimeException(("Illegal union index for 'F643': "+ unionIndex643)); + } + } + int unionIndex644 = (decoder.readIndex()); + if (unionIndex644 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(644, null); + } else { + if (unionIndex644 == 1) { + Utf8 charSequence644; + Object oldString644 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(644); + if (oldString644 instanceof Utf8) { + charSequence644 = (decoder).readString(((Utf8) oldString644)); + } else { + charSequence644 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(644, charSequence644); + } else { + throw new RuntimeException(("Illegal union index for 'F644': "+ unionIndex644)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex645 = (decoder.readIndex()); + if (unionIndex645 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(645, null); + } else { + if (unionIndex645 == 1) { + Utf8 charSequence645; + Object oldString645 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(645); + if (oldString645 instanceof Utf8) { + charSequence645 = (decoder).readString(((Utf8) oldString645)); + } else { + charSequence645 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(645, charSequence645); + } else { + throw new RuntimeException(("Illegal union index for 'F645': "+ unionIndex645)); + } + } + int unionIndex646 = (decoder.readIndex()); + if (unionIndex646 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(646, null); + } else { + if (unionIndex646 == 1) { + Utf8 charSequence646; + Object oldString646 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(646); + if (oldString646 instanceof Utf8) { + charSequence646 = (decoder).readString(((Utf8) oldString646)); + } else { + charSequence646 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(646, charSequence646); + } else { + throw new RuntimeException(("Illegal union index for 'F646': "+ unionIndex646)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex647 = (decoder.readIndex()); + if (unionIndex647 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(647, null); + } else { + if (unionIndex647 == 1) { + Utf8 charSequence647; + Object oldString647 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(647); + if (oldString647 instanceof Utf8) { + charSequence647 = (decoder).readString(((Utf8) oldString647)); + } else { + charSequence647 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(647, charSequence647); + } else { + throw new RuntimeException(("Illegal union index for 'F647': "+ unionIndex647)); + } + } + int unionIndex648 = (decoder.readIndex()); + if (unionIndex648 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(648, null); + } else { + if (unionIndex648 == 1) { + Utf8 charSequence648; + Object oldString648 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(648); + if (oldString648 instanceof Utf8) { + charSequence648 = (decoder).readString(((Utf8) oldString648)); + } else { + charSequence648 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(648, charSequence648); + } else { + throw new RuntimeException(("Illegal union index for 'F648': "+ unionIndex648)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex649 = (decoder.readIndex()); + if (unionIndex649 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(649, null); + } else { + if (unionIndex649 == 1) { + Utf8 charSequence649; + Object oldString649 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(649); + if (oldString649 instanceof Utf8) { + charSequence649 = (decoder).readString(((Utf8) oldString649)); + } else { + charSequence649 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(649, charSequence649); + } else { + throw new RuntimeException(("Illegal union index for 'F649': "+ unionIndex649)); + } + } + int unionIndex650 = (decoder.readIndex()); + if (unionIndex650 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(650, null); + } else { + if (unionIndex650 == 1) { + Utf8 charSequence650; + Object oldString650 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(650); + if (oldString650 instanceof Utf8) { + charSequence650 = (decoder).readString(((Utf8) oldString650)); + } else { + charSequence650 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(650, charSequence650); + } else { + throw new RuntimeException(("Illegal union index for 'F650': "+ unionIndex650)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex651 = (decoder.readIndex()); + if (unionIndex651 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(651, null); + } else { + if (unionIndex651 == 1) { + Utf8 charSequence651; + Object oldString651 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(651); + if (oldString651 instanceof Utf8) { + charSequence651 = (decoder).readString(((Utf8) oldString651)); + } else { + charSequence651 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(651, charSequence651); + } else { + throw new RuntimeException(("Illegal union index for 'F651': "+ unionIndex651)); + } + } + int unionIndex652 = (decoder.readIndex()); + if (unionIndex652 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(652, null); + } else { + if (unionIndex652 == 1) { + Utf8 charSequence652; + Object oldString652 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(652); + if (oldString652 instanceof Utf8) { + charSequence652 = (decoder).readString(((Utf8) oldString652)); + } else { + charSequence652 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(652, charSequence652); + } else { + throw new RuntimeException(("Illegal union index for 'F652': "+ unionIndex652)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex653 = (decoder.readIndex()); + if (unionIndex653 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(653, null); + } else { + if (unionIndex653 == 1) { + Utf8 charSequence653; + Object oldString653 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(653); + if (oldString653 instanceof Utf8) { + charSequence653 = (decoder).readString(((Utf8) oldString653)); + } else { + charSequence653 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(653, charSequence653); + } else { + throw new RuntimeException(("Illegal union index for 'F653': "+ unionIndex653)); + } + } + int unionIndex654 = (decoder.readIndex()); + if (unionIndex654 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(654, null); + } else { + if (unionIndex654 == 1) { + Utf8 charSequence654; + Object oldString654 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(654); + if (oldString654 instanceof Utf8) { + charSequence654 = (decoder).readString(((Utf8) oldString654)); + } else { + charSequence654 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(654, charSequence654); + } else { + throw new RuntimeException(("Illegal union index for 'F654': "+ unionIndex654)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex655 = (decoder.readIndex()); + if (unionIndex655 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(655, null); + } else { + if (unionIndex655 == 1) { + Utf8 charSequence655; + Object oldString655 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(655); + if (oldString655 instanceof Utf8) { + charSequence655 = (decoder).readString(((Utf8) oldString655)); + } else { + charSequence655 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(655, charSequence655); + } else { + throw new RuntimeException(("Illegal union index for 'F655': "+ unionIndex655)); + } + } + int unionIndex656 = (decoder.readIndex()); + if (unionIndex656 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(656, null); + } else { + if (unionIndex656 == 1) { + Utf8 charSequence656; + Object oldString656 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(656); + if (oldString656 instanceof Utf8) { + charSequence656 = (decoder).readString(((Utf8) oldString656)); + } else { + charSequence656 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(656, charSequence656); + } else { + throw new RuntimeException(("Illegal union index for 'F656': "+ unionIndex656)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex657 = (decoder.readIndex()); + if (unionIndex657 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(657, null); + } else { + if (unionIndex657 == 1) { + Utf8 charSequence657; + Object oldString657 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(657); + if (oldString657 instanceof Utf8) { + charSequence657 = (decoder).readString(((Utf8) oldString657)); + } else { + charSequence657 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(657, charSequence657); + } else { + throw new RuntimeException(("Illegal union index for 'F657': "+ unionIndex657)); + } + } + int unionIndex658 = (decoder.readIndex()); + if (unionIndex658 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(658, null); + } else { + if (unionIndex658 == 1) { + Utf8 charSequence658; + Object oldString658 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(658); + if (oldString658 instanceof Utf8) { + charSequence658 = (decoder).readString(((Utf8) oldString658)); + } else { + charSequence658 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(658, charSequence658); + } else { + throw new RuntimeException(("Illegal union index for 'F658': "+ unionIndex658)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex659 = (decoder.readIndex()); + if (unionIndex659 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(659, null); + } else { + if (unionIndex659 == 1) { + Utf8 charSequence659; + Object oldString659 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(659); + if (oldString659 instanceof Utf8) { + charSequence659 = (decoder).readString(((Utf8) oldString659)); + } else { + charSequence659 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(659, charSequence659); + } else { + throw new RuntimeException(("Illegal union index for 'F659': "+ unionIndex659)); + } + } + int unionIndex660 = (decoder.readIndex()); + if (unionIndex660 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(660, null); + } else { + if (unionIndex660 == 1) { + Utf8 charSequence660; + Object oldString660 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(660); + if (oldString660 instanceof Utf8) { + charSequence660 = (decoder).readString(((Utf8) oldString660)); + } else { + charSequence660 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(660, charSequence660); + } else { + throw new RuntimeException(("Illegal union index for 'F660': "+ unionIndex660)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex661 = (decoder.readIndex()); + if (unionIndex661 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(661, null); + } else { + if (unionIndex661 == 1) { + Utf8 charSequence661; + Object oldString661 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(661); + if (oldString661 instanceof Utf8) { + charSequence661 = (decoder).readString(((Utf8) oldString661)); + } else { + charSequence661 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(661, charSequence661); + } else { + throw new RuntimeException(("Illegal union index for 'F661': "+ unionIndex661)); + } + } + int unionIndex662 = (decoder.readIndex()); + if (unionIndex662 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(662, null); + } else { + if (unionIndex662 == 1) { + Utf8 charSequence662; + Object oldString662 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(662); + if (oldString662 instanceof Utf8) { + charSequence662 = (decoder).readString(((Utf8) oldString662)); + } else { + charSequence662 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(662, charSequence662); + } else { + throw new RuntimeException(("Illegal union index for 'F662': "+ unionIndex662)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex663 = (decoder.readIndex()); + if (unionIndex663 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(663, null); + } else { + if (unionIndex663 == 1) { + Utf8 charSequence663; + Object oldString663 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(663); + if (oldString663 instanceof Utf8) { + charSequence663 = (decoder).readString(((Utf8) oldString663)); + } else { + charSequence663 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(663, charSequence663); + } else { + throw new RuntimeException(("Illegal union index for 'F663': "+ unionIndex663)); + } + } + int unionIndex664 = (decoder.readIndex()); + if (unionIndex664 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(664, null); + } else { + if (unionIndex664 == 1) { + Utf8 charSequence664; + Object oldString664 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(664); + if (oldString664 instanceof Utf8) { + charSequence664 = (decoder).readString(((Utf8) oldString664)); + } else { + charSequence664 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(664, charSequence664); + } else { + throw new RuntimeException(("Illegal union index for 'F664': "+ unionIndex664)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex665 = (decoder.readIndex()); + if (unionIndex665 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(665, null); + } else { + if (unionIndex665 == 1) { + Utf8 charSequence665; + Object oldString665 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(665); + if (oldString665 instanceof Utf8) { + charSequence665 = (decoder).readString(((Utf8) oldString665)); + } else { + charSequence665 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(665, charSequence665); + } else { + throw new RuntimeException(("Illegal union index for 'F665': "+ unionIndex665)); + } + } + int unionIndex666 = (decoder.readIndex()); + if (unionIndex666 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(666, null); + } else { + if (unionIndex666 == 1) { + Utf8 charSequence666; + Object oldString666 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(666); + if (oldString666 instanceof Utf8) { + charSequence666 = (decoder).readString(((Utf8) oldString666)); + } else { + charSequence666 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(666, charSequence666); + } else { + throw new RuntimeException(("Illegal union index for 'F666': "+ unionIndex666)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex667 = (decoder.readIndex()); + if (unionIndex667 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(667, null); + } else { + if (unionIndex667 == 1) { + Utf8 charSequence667; + Object oldString667 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(667); + if (oldString667 instanceof Utf8) { + charSequence667 = (decoder).readString(((Utf8) oldString667)); + } else { + charSequence667 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(667, charSequence667); + } else { + throw new RuntimeException(("Illegal union index for 'F667': "+ unionIndex667)); + } + } + int unionIndex668 = (decoder.readIndex()); + if (unionIndex668 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(668, null); + } else { + if (unionIndex668 == 1) { + Utf8 charSequence668; + Object oldString668 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(668); + if (oldString668 instanceof Utf8) { + charSequence668 = (decoder).readString(((Utf8) oldString668)); + } else { + charSequence668 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(668, charSequence668); + } else { + throw new RuntimeException(("Illegal union index for 'F668': "+ unionIndex668)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex669 = (decoder.readIndex()); + if (unionIndex669 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(669, null); + } else { + if (unionIndex669 == 1) { + Utf8 charSequence669; + Object oldString669 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(669); + if (oldString669 instanceof Utf8) { + charSequence669 = (decoder).readString(((Utf8) oldString669)); + } else { + charSequence669 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(669, charSequence669); + } else { + throw new RuntimeException(("Illegal union index for 'F669': "+ unionIndex669)); + } + } + int unionIndex670 = (decoder.readIndex()); + if (unionIndex670 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(670, null); + } else { + if (unionIndex670 == 1) { + Utf8 charSequence670; + Object oldString670 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(670); + if (oldString670 instanceof Utf8) { + charSequence670 = (decoder).readString(((Utf8) oldString670)); + } else { + charSequence670 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(670, charSequence670); + } else { + throw new RuntimeException(("Illegal union index for 'F670': "+ unionIndex670)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex671 = (decoder.readIndex()); + if (unionIndex671 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(671, null); + } else { + if (unionIndex671 == 1) { + Utf8 charSequence671; + Object oldString671 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(671); + if (oldString671 instanceof Utf8) { + charSequence671 = (decoder).readString(((Utf8) oldString671)); + } else { + charSequence671 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(671, charSequence671); + } else { + throw new RuntimeException(("Illegal union index for 'F671': "+ unionIndex671)); + } + } + int unionIndex672 = (decoder.readIndex()); + if (unionIndex672 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(672, null); + } else { + if (unionIndex672 == 1) { + Utf8 charSequence672; + Object oldString672 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(672); + if (oldString672 instanceof Utf8) { + charSequence672 = (decoder).readString(((Utf8) oldString672)); + } else { + charSequence672 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(672, charSequence672); + } else { + throw new RuntimeException(("Illegal union index for 'F672': "+ unionIndex672)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex673 = (decoder.readIndex()); + if (unionIndex673 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(673, null); + } else { + if (unionIndex673 == 1) { + Utf8 charSequence673; + Object oldString673 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(673); + if (oldString673 instanceof Utf8) { + charSequence673 = (decoder).readString(((Utf8) oldString673)); + } else { + charSequence673 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(673, charSequence673); + } else { + throw new RuntimeException(("Illegal union index for 'F673': "+ unionIndex673)); + } + } + int unionIndex674 = (decoder.readIndex()); + if (unionIndex674 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(674, null); + } else { + if (unionIndex674 == 1) { + Utf8 charSequence674; + Object oldString674 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(674); + if (oldString674 instanceof Utf8) { + charSequence674 = (decoder).readString(((Utf8) oldString674)); + } else { + charSequence674 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(674, charSequence674); + } else { + throw new RuntimeException(("Illegal union index for 'F674': "+ unionIndex674)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex675 = (decoder.readIndex()); + if (unionIndex675 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(675, null); + } else { + if (unionIndex675 == 1) { + Utf8 charSequence675; + Object oldString675 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(675); + if (oldString675 instanceof Utf8) { + charSequence675 = (decoder).readString(((Utf8) oldString675)); + } else { + charSequence675 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(675, charSequence675); + } else { + throw new RuntimeException(("Illegal union index for 'F675': "+ unionIndex675)); + } + } + int unionIndex676 = (decoder.readIndex()); + if (unionIndex676 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(676, null); + } else { + if (unionIndex676 == 1) { + Utf8 charSequence676; + Object oldString676 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(676); + if (oldString676 instanceof Utf8) { + charSequence676 = (decoder).readString(((Utf8) oldString676)); + } else { + charSequence676 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(676, charSequence676); + } else { + throw new RuntimeException(("Illegal union index for 'F676': "+ unionIndex676)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex677 = (decoder.readIndex()); + if (unionIndex677 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(677, null); + } else { + if (unionIndex677 == 1) { + Utf8 charSequence677; + Object oldString677 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(677); + if (oldString677 instanceof Utf8) { + charSequence677 = (decoder).readString(((Utf8) oldString677)); + } else { + charSequence677 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(677, charSequence677); + } else { + throw new RuntimeException(("Illegal union index for 'F677': "+ unionIndex677)); + } + } + int unionIndex678 = (decoder.readIndex()); + if (unionIndex678 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(678, null); + } else { + if (unionIndex678 == 1) { + Utf8 charSequence678; + Object oldString678 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(678); + if (oldString678 instanceof Utf8) { + charSequence678 = (decoder).readString(((Utf8) oldString678)); + } else { + charSequence678 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(678, charSequence678); + } else { + throw new RuntimeException(("Illegal union index for 'F678': "+ unionIndex678)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex679 = (decoder.readIndex()); + if (unionIndex679 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(679, null); + } else { + if (unionIndex679 == 1) { + Utf8 charSequence679; + Object oldString679 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(679); + if (oldString679 instanceof Utf8) { + charSequence679 = (decoder).readString(((Utf8) oldString679)); + } else { + charSequence679 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(679, charSequence679); + } else { + throw new RuntimeException(("Illegal union index for 'F679': "+ unionIndex679)); + } + } + int unionIndex680 = (decoder.readIndex()); + if (unionIndex680 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(680, null); + } else { + if (unionIndex680 == 1) { + Utf8 charSequence680; + Object oldString680 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(680); + if (oldString680 instanceof Utf8) { + charSequence680 = (decoder).readString(((Utf8) oldString680)); + } else { + charSequence680 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(680, charSequence680); + } else { + throw new RuntimeException(("Illegal union index for 'F680': "+ unionIndex680)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex681 = (decoder.readIndex()); + if (unionIndex681 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(681, null); + } else { + if (unionIndex681 == 1) { + Utf8 charSequence681; + Object oldString681 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(681); + if (oldString681 instanceof Utf8) { + charSequence681 = (decoder).readString(((Utf8) oldString681)); + } else { + charSequence681 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(681, charSequence681); + } else { + throw new RuntimeException(("Illegal union index for 'F681': "+ unionIndex681)); + } + } + int unionIndex682 = (decoder.readIndex()); + if (unionIndex682 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(682, null); + } else { + if (unionIndex682 == 1) { + Utf8 charSequence682; + Object oldString682 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(682); + if (oldString682 instanceof Utf8) { + charSequence682 = (decoder).readString(((Utf8) oldString682)); + } else { + charSequence682 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(682, charSequence682); + } else { + throw new RuntimeException(("Illegal union index for 'F682': "+ unionIndex682)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex683 = (decoder.readIndex()); + if (unionIndex683 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(683, null); + } else { + if (unionIndex683 == 1) { + Utf8 charSequence683; + Object oldString683 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(683); + if (oldString683 instanceof Utf8) { + charSequence683 = (decoder).readString(((Utf8) oldString683)); + } else { + charSequence683 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(683, charSequence683); + } else { + throw new RuntimeException(("Illegal union index for 'F683': "+ unionIndex683)); + } + } + int unionIndex684 = (decoder.readIndex()); + if (unionIndex684 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(684, null); + } else { + if (unionIndex684 == 1) { + Utf8 charSequence684; + Object oldString684 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(684); + if (oldString684 instanceof Utf8) { + charSequence684 = (decoder).readString(((Utf8) oldString684)); + } else { + charSequence684 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(684, charSequence684); + } else { + throw new RuntimeException(("Illegal union index for 'F684': "+ unionIndex684)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex685 = (decoder.readIndex()); + if (unionIndex685 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(685, null); + } else { + if (unionIndex685 == 1) { + Utf8 charSequence685; + Object oldString685 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(685); + if (oldString685 instanceof Utf8) { + charSequence685 = (decoder).readString(((Utf8) oldString685)); + } else { + charSequence685 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(685, charSequence685); + } else { + throw new RuntimeException(("Illegal union index for 'F685': "+ unionIndex685)); + } + } + int unionIndex686 = (decoder.readIndex()); + if (unionIndex686 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(686, null); + } else { + if (unionIndex686 == 1) { + Utf8 charSequence686; + Object oldString686 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(686); + if (oldString686 instanceof Utf8) { + charSequence686 = (decoder).readString(((Utf8) oldString686)); + } else { + charSequence686 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(686, charSequence686); + } else { + throw new RuntimeException(("Illegal union index for 'F686': "+ unionIndex686)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex687 = (decoder.readIndex()); + if (unionIndex687 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(687, null); + } else { + if (unionIndex687 == 1) { + Utf8 charSequence687; + Object oldString687 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(687); + if (oldString687 instanceof Utf8) { + charSequence687 = (decoder).readString(((Utf8) oldString687)); + } else { + charSequence687 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(687, charSequence687); + } else { + throw new RuntimeException(("Illegal union index for 'F687': "+ unionIndex687)); + } + } + int unionIndex688 = (decoder.readIndex()); + if (unionIndex688 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(688, null); + } else { + if (unionIndex688 == 1) { + Utf8 charSequence688; + Object oldString688 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(688); + if (oldString688 instanceof Utf8) { + charSequence688 = (decoder).readString(((Utf8) oldString688)); + } else { + charSequence688 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(688, charSequence688); + } else { + throw new RuntimeException(("Illegal union index for 'F688': "+ unionIndex688)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex689 = (decoder.readIndex()); + if (unionIndex689 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(689, null); + } else { + if (unionIndex689 == 1) { + Utf8 charSequence689; + Object oldString689 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(689); + if (oldString689 instanceof Utf8) { + charSequence689 = (decoder).readString(((Utf8) oldString689)); + } else { + charSequence689 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(689, charSequence689); + } else { + throw new RuntimeException(("Illegal union index for 'F689': "+ unionIndex689)); + } + } + int unionIndex690 = (decoder.readIndex()); + if (unionIndex690 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(690, null); + } else { + if (unionIndex690 == 1) { + Utf8 charSequence690; + Object oldString690 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(690); + if (oldString690 instanceof Utf8) { + charSequence690 = (decoder).readString(((Utf8) oldString690)); + } else { + charSequence690 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(690, charSequence690); + } else { + throw new RuntimeException(("Illegal union index for 'F690': "+ unionIndex690)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex691 = (decoder.readIndex()); + if (unionIndex691 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(691, null); + } else { + if (unionIndex691 == 1) { + Utf8 charSequence691; + Object oldString691 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(691); + if (oldString691 instanceof Utf8) { + charSequence691 = (decoder).readString(((Utf8) oldString691)); + } else { + charSequence691 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(691, charSequence691); + } else { + throw new RuntimeException(("Illegal union index for 'F691': "+ unionIndex691)); + } + } + int unionIndex692 = (decoder.readIndex()); + if (unionIndex692 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(692, null); + } else { + if (unionIndex692 == 1) { + Utf8 charSequence692; + Object oldString692 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(692); + if (oldString692 instanceof Utf8) { + charSequence692 = (decoder).readString(((Utf8) oldString692)); + } else { + charSequence692 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(692, charSequence692); + } else { + throw new RuntimeException(("Illegal union index for 'F692': "+ unionIndex692)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex693 = (decoder.readIndex()); + if (unionIndex693 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(693, null); + } else { + if (unionIndex693 == 1) { + Utf8 charSequence693; + Object oldString693 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(693); + if (oldString693 instanceof Utf8) { + charSequence693 = (decoder).readString(((Utf8) oldString693)); + } else { + charSequence693 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(693, charSequence693); + } else { + throw new RuntimeException(("Illegal union index for 'F693': "+ unionIndex693)); + } + } + int unionIndex694 = (decoder.readIndex()); + if (unionIndex694 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(694, null); + } else { + if (unionIndex694 == 1) { + Utf8 charSequence694; + Object oldString694 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(694); + if (oldString694 instanceof Utf8) { + charSequence694 = (decoder).readString(((Utf8) oldString694)); + } else { + charSequence694 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(694, charSequence694); + } else { + throw new RuntimeException(("Illegal union index for 'F694': "+ unionIndex694)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex695 = (decoder.readIndex()); + if (unionIndex695 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(695, null); + } else { + if (unionIndex695 == 1) { + Utf8 charSequence695; + Object oldString695 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(695); + if (oldString695 instanceof Utf8) { + charSequence695 = (decoder).readString(((Utf8) oldString695)); + } else { + charSequence695 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(695, charSequence695); + } else { + throw new RuntimeException(("Illegal union index for 'F695': "+ unionIndex695)); + } + } + int unionIndex696 = (decoder.readIndex()); + if (unionIndex696 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(696, null); + } else { + if (unionIndex696 == 1) { + Utf8 charSequence696; + Object oldString696 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(696); + if (oldString696 instanceof Utf8) { + charSequence696 = (decoder).readString(((Utf8) oldString696)); + } else { + charSequence696 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(696, charSequence696); + } else { + throw new RuntimeException(("Illegal union index for 'F696': "+ unionIndex696)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex697 = (decoder.readIndex()); + if (unionIndex697 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(697, null); + } else { + if (unionIndex697 == 1) { + Utf8 charSequence697; + Object oldString697 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(697); + if (oldString697 instanceof Utf8) { + charSequence697 = (decoder).readString(((Utf8) oldString697)); + } else { + charSequence697 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(697, charSequence697); + } else { + throw new RuntimeException(("Illegal union index for 'F697': "+ unionIndex697)); + } + } + int unionIndex698 = (decoder.readIndex()); + if (unionIndex698 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(698, null); + } else { + if (unionIndex698 == 1) { + Utf8 charSequence698; + Object oldString698 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(698); + if (oldString698 instanceof Utf8) { + charSequence698 = (decoder).readString(((Utf8) oldString698)); + } else { + charSequence698 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(698, charSequence698); + } else { + throw new RuntimeException(("Illegal union index for 'F698': "+ unionIndex698)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex699 = (decoder.readIndex()); + if (unionIndex699 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(699, null); + } else { + if (unionIndex699 == 1) { + Utf8 charSequence699; + Object oldString699 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(699); + if (oldString699 instanceof Utf8) { + charSequence699 = (decoder).readString(((Utf8) oldString699)); + } else { + charSequence699 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(699, charSequence699); + } else { + throw new RuntimeException(("Illegal union index for 'F699': "+ unionIndex699)); + } + } + int unionIndex700 = (decoder.readIndex()); + if (unionIndex700 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(700, null); + } else { + if (unionIndex700 == 1) { + Utf8 charSequence700; + Object oldString700 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(700); + if (oldString700 instanceof Utf8) { + charSequence700 = (decoder).readString(((Utf8) oldString700)); + } else { + charSequence700 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(700, charSequence700); + } else { + throw new RuntimeException(("Illegal union index for 'F700': "+ unionIndex700)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex701 = (decoder.readIndex()); + if (unionIndex701 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(701, null); + } else { + if (unionIndex701 == 1) { + Utf8 charSequence701; + Object oldString701 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(701); + if (oldString701 instanceof Utf8) { + charSequence701 = (decoder).readString(((Utf8) oldString701)); + } else { + charSequence701 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(701, charSequence701); + } else { + throw new RuntimeException(("Illegal union index for 'F701': "+ unionIndex701)); + } + } + int unionIndex702 = (decoder.readIndex()); + if (unionIndex702 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(702, null); + } else { + if (unionIndex702 == 1) { + Utf8 charSequence702; + Object oldString702 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(702); + if (oldString702 instanceof Utf8) { + charSequence702 = (decoder).readString(((Utf8) oldString702)); + } else { + charSequence702 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(702, charSequence702); + } else { + throw new RuntimeException(("Illegal union index for 'F702': "+ unionIndex702)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex703 = (decoder.readIndex()); + if (unionIndex703 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(703, null); + } else { + if (unionIndex703 == 1) { + Utf8 charSequence703; + Object oldString703 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(703); + if (oldString703 instanceof Utf8) { + charSequence703 = (decoder).readString(((Utf8) oldString703)); + } else { + charSequence703 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(703, charSequence703); + } else { + throw new RuntimeException(("Illegal union index for 'F703': "+ unionIndex703)); + } + } + int unionIndex704 = (decoder.readIndex()); + if (unionIndex704 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(704, null); + } else { + if (unionIndex704 == 1) { + Utf8 charSequence704; + Object oldString704 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(704); + if (oldString704 instanceof Utf8) { + charSequence704 = (decoder).readString(((Utf8) oldString704)); + } else { + charSequence704 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(704, charSequence704); + } else { + throw new RuntimeException(("Illegal union index for 'F704': "+ unionIndex704)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex705 = (decoder.readIndex()); + if (unionIndex705 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(705, null); + } else { + if (unionIndex705 == 1) { + Utf8 charSequence705; + Object oldString705 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(705); + if (oldString705 instanceof Utf8) { + charSequence705 = (decoder).readString(((Utf8) oldString705)); + } else { + charSequence705 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(705, charSequence705); + } else { + throw new RuntimeException(("Illegal union index for 'F705': "+ unionIndex705)); + } + } + int unionIndex706 = (decoder.readIndex()); + if (unionIndex706 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(706, null); + } else { + if (unionIndex706 == 1) { + Utf8 charSequence706; + Object oldString706 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(706); + if (oldString706 instanceof Utf8) { + charSequence706 = (decoder).readString(((Utf8) oldString706)); + } else { + charSequence706 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(706, charSequence706); + } else { + throw new RuntimeException(("Illegal union index for 'F706': "+ unionIndex706)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex707 = (decoder.readIndex()); + if (unionIndex707 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(707, null); + } else { + if (unionIndex707 == 1) { + Utf8 charSequence707; + Object oldString707 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(707); + if (oldString707 instanceof Utf8) { + charSequence707 = (decoder).readString(((Utf8) oldString707)); + } else { + charSequence707 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(707, charSequence707); + } else { + throw new RuntimeException(("Illegal union index for 'F707': "+ unionIndex707)); + } + } + int unionIndex708 = (decoder.readIndex()); + if (unionIndex708 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(708, null); + } else { + if (unionIndex708 == 1) { + Utf8 charSequence708; + Object oldString708 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(708); + if (oldString708 instanceof Utf8) { + charSequence708 = (decoder).readString(((Utf8) oldString708)); + } else { + charSequence708 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(708, charSequence708); + } else { + throw new RuntimeException(("Illegal union index for 'F708': "+ unionIndex708)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex709 = (decoder.readIndex()); + if (unionIndex709 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(709, null); + } else { + if (unionIndex709 == 1) { + Utf8 charSequence709; + Object oldString709 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(709); + if (oldString709 instanceof Utf8) { + charSequence709 = (decoder).readString(((Utf8) oldString709)); + } else { + charSequence709 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(709, charSequence709); + } else { + throw new RuntimeException(("Illegal union index for 'F709': "+ unionIndex709)); + } + } + int unionIndex710 = (decoder.readIndex()); + if (unionIndex710 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(710, null); + } else { + if (unionIndex710 == 1) { + Utf8 charSequence710; + Object oldString710 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(710); + if (oldString710 instanceof Utf8) { + charSequence710 = (decoder).readString(((Utf8) oldString710)); + } else { + charSequence710 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(710, charSequence710); + } else { + throw new RuntimeException(("Illegal union index for 'F710': "+ unionIndex710)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex711 = (decoder.readIndex()); + if (unionIndex711 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(711, null); + } else { + if (unionIndex711 == 1) { + Utf8 charSequence711; + Object oldString711 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(711); + if (oldString711 instanceof Utf8) { + charSequence711 = (decoder).readString(((Utf8) oldString711)); + } else { + charSequence711 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(711, charSequence711); + } else { + throw new RuntimeException(("Illegal union index for 'F711': "+ unionIndex711)); + } + } + int unionIndex712 = (decoder.readIndex()); + if (unionIndex712 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(712, null); + } else { + if (unionIndex712 == 1) { + Utf8 charSequence712; + Object oldString712 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(712); + if (oldString712 instanceof Utf8) { + charSequence712 = (decoder).readString(((Utf8) oldString712)); + } else { + charSequence712 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(712, charSequence712); + } else { + throw new RuntimeException(("Illegal union index for 'F712': "+ unionIndex712)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex713 = (decoder.readIndex()); + if (unionIndex713 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(713, null); + } else { + if (unionIndex713 == 1) { + Utf8 charSequence713; + Object oldString713 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(713); + if (oldString713 instanceof Utf8) { + charSequence713 = (decoder).readString(((Utf8) oldString713)); + } else { + charSequence713 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(713, charSequence713); + } else { + throw new RuntimeException(("Illegal union index for 'F713': "+ unionIndex713)); + } + } + int unionIndex714 = (decoder.readIndex()); + if (unionIndex714 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(714, null); + } else { + if (unionIndex714 == 1) { + Utf8 charSequence714; + Object oldString714 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(714); + if (oldString714 instanceof Utf8) { + charSequence714 = (decoder).readString(((Utf8) oldString714)); + } else { + charSequence714 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(714, charSequence714); + } else { + throw new RuntimeException(("Illegal union index for 'F714': "+ unionIndex714)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex715 = (decoder.readIndex()); + if (unionIndex715 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(715, null); + } else { + if (unionIndex715 == 1) { + Utf8 charSequence715; + Object oldString715 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(715); + if (oldString715 instanceof Utf8) { + charSequence715 = (decoder).readString(((Utf8) oldString715)); + } else { + charSequence715 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(715, charSequence715); + } else { + throw new RuntimeException(("Illegal union index for 'F715': "+ unionIndex715)); + } + } + int unionIndex716 = (decoder.readIndex()); + if (unionIndex716 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(716, null); + } else { + if (unionIndex716 == 1) { + Utf8 charSequence716; + Object oldString716 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(716); + if (oldString716 instanceof Utf8) { + charSequence716 = (decoder).readString(((Utf8) oldString716)); + } else { + charSequence716 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(716, charSequence716); + } else { + throw new RuntimeException(("Illegal union index for 'F716': "+ unionIndex716)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex717 = (decoder.readIndex()); + if (unionIndex717 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(717, null); + } else { + if (unionIndex717 == 1) { + Utf8 charSequence717; + Object oldString717 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(717); + if (oldString717 instanceof Utf8) { + charSequence717 = (decoder).readString(((Utf8) oldString717)); + } else { + charSequence717 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(717, charSequence717); + } else { + throw new RuntimeException(("Illegal union index for 'F717': "+ unionIndex717)); + } + } + int unionIndex718 = (decoder.readIndex()); + if (unionIndex718 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(718, null); + } else { + if (unionIndex718 == 1) { + Utf8 charSequence718; + Object oldString718 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(718); + if (oldString718 instanceof Utf8) { + charSequence718 = (decoder).readString(((Utf8) oldString718)); + } else { + charSequence718 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(718, charSequence718); + } else { + throw new RuntimeException(("Illegal union index for 'F718': "+ unionIndex718)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex719 = (decoder.readIndex()); + if (unionIndex719 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(719, null); + } else { + if (unionIndex719 == 1) { + Utf8 charSequence719; + Object oldString719 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(719); + if (oldString719 instanceof Utf8) { + charSequence719 = (decoder).readString(((Utf8) oldString719)); + } else { + charSequence719 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(719, charSequence719); + } else { + throw new RuntimeException(("Illegal union index for 'F719': "+ unionIndex719)); + } + } + int unionIndex720 = (decoder.readIndex()); + if (unionIndex720 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(720, null); + } else { + if (unionIndex720 == 1) { + Utf8 charSequence720; + Object oldString720 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(720); + if (oldString720 instanceof Utf8) { + charSequence720 = (decoder).readString(((Utf8) oldString720)); + } else { + charSequence720 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(720, charSequence720); + } else { + throw new RuntimeException(("Illegal union index for 'F720': "+ unionIndex720)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex721 = (decoder.readIndex()); + if (unionIndex721 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(721, null); + } else { + if (unionIndex721 == 1) { + Utf8 charSequence721; + Object oldString721 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(721); + if (oldString721 instanceof Utf8) { + charSequence721 = (decoder).readString(((Utf8) oldString721)); + } else { + charSequence721 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(721, charSequence721); + } else { + throw new RuntimeException(("Illegal union index for 'F721': "+ unionIndex721)); + } + } + int unionIndex722 = (decoder.readIndex()); + if (unionIndex722 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(722, null); + } else { + if (unionIndex722 == 1) { + Utf8 charSequence722; + Object oldString722 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(722); + if (oldString722 instanceof Utf8) { + charSequence722 = (decoder).readString(((Utf8) oldString722)); + } else { + charSequence722 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(722, charSequence722); + } else { + throw new RuntimeException(("Illegal union index for 'F722': "+ unionIndex722)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex723 = (decoder.readIndex()); + if (unionIndex723 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(723, null); + } else { + if (unionIndex723 == 1) { + Utf8 charSequence723; + Object oldString723 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(723); + if (oldString723 instanceof Utf8) { + charSequence723 = (decoder).readString(((Utf8) oldString723)); + } else { + charSequence723 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(723, charSequence723); + } else { + throw new RuntimeException(("Illegal union index for 'F723': "+ unionIndex723)); + } + } + int unionIndex724 = (decoder.readIndex()); + if (unionIndex724 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(724, null); + } else { + if (unionIndex724 == 1) { + Utf8 charSequence724; + Object oldString724 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(724); + if (oldString724 instanceof Utf8) { + charSequence724 = (decoder).readString(((Utf8) oldString724)); + } else { + charSequence724 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(724, charSequence724); + } else { + throw new RuntimeException(("Illegal union index for 'F724': "+ unionIndex724)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex725 = (decoder.readIndex()); + if (unionIndex725 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(725, null); + } else { + if (unionIndex725 == 1) { + Utf8 charSequence725; + Object oldString725 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(725); + if (oldString725 instanceof Utf8) { + charSequence725 = (decoder).readString(((Utf8) oldString725)); + } else { + charSequence725 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(725, charSequence725); + } else { + throw new RuntimeException(("Illegal union index for 'F725': "+ unionIndex725)); + } + } + int unionIndex726 = (decoder.readIndex()); + if (unionIndex726 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(726, null); + } else { + if (unionIndex726 == 1) { + Utf8 charSequence726; + Object oldString726 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(726); + if (oldString726 instanceof Utf8) { + charSequence726 = (decoder).readString(((Utf8) oldString726)); + } else { + charSequence726 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(726, charSequence726); + } else { + throw new RuntimeException(("Illegal union index for 'F726': "+ unionIndex726)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex727 = (decoder.readIndex()); + if (unionIndex727 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(727, null); + } else { + if (unionIndex727 == 1) { + Utf8 charSequence727; + Object oldString727 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(727); + if (oldString727 instanceof Utf8) { + charSequence727 = (decoder).readString(((Utf8) oldString727)); + } else { + charSequence727 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(727, charSequence727); + } else { + throw new RuntimeException(("Illegal union index for 'F727': "+ unionIndex727)); + } + } + int unionIndex728 = (decoder.readIndex()); + if (unionIndex728 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(728, null); + } else { + if (unionIndex728 == 1) { + Utf8 charSequence728; + Object oldString728 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(728); + if (oldString728 instanceof Utf8) { + charSequence728 = (decoder).readString(((Utf8) oldString728)); + } else { + charSequence728 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(728, charSequence728); + } else { + throw new RuntimeException(("Illegal union index for 'F728': "+ unionIndex728)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex729 = (decoder.readIndex()); + if (unionIndex729 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(729, null); + } else { + if (unionIndex729 == 1) { + Utf8 charSequence729; + Object oldString729 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(729); + if (oldString729 instanceof Utf8) { + charSequence729 = (decoder).readString(((Utf8) oldString729)); + } else { + charSequence729 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(729, charSequence729); + } else { + throw new RuntimeException(("Illegal union index for 'F729': "+ unionIndex729)); + } + } + int unionIndex730 = (decoder.readIndex()); + if (unionIndex730 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(730, null); + } else { + if (unionIndex730 == 1) { + Utf8 charSequence730; + Object oldString730 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(730); + if (oldString730 instanceof Utf8) { + charSequence730 = (decoder).readString(((Utf8) oldString730)); + } else { + charSequence730 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(730, charSequence730); + } else { + throw new RuntimeException(("Illegal union index for 'F730': "+ unionIndex730)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex731 = (decoder.readIndex()); + if (unionIndex731 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(731, null); + } else { + if (unionIndex731 == 1) { + Utf8 charSequence731; + Object oldString731 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(731); + if (oldString731 instanceof Utf8) { + charSequence731 = (decoder).readString(((Utf8) oldString731)); + } else { + charSequence731 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(731, charSequence731); + } else { + throw new RuntimeException(("Illegal union index for 'F731': "+ unionIndex731)); + } + } + int unionIndex732 = (decoder.readIndex()); + if (unionIndex732 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(732, null); + } else { + if (unionIndex732 == 1) { + Utf8 charSequence732; + Object oldString732 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(732); + if (oldString732 instanceof Utf8) { + charSequence732 = (decoder).readString(((Utf8) oldString732)); + } else { + charSequence732 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(732, charSequence732); + } else { + throw new RuntimeException(("Illegal union index for 'F732': "+ unionIndex732)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex733 = (decoder.readIndex()); + if (unionIndex733 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(733, null); + } else { + if (unionIndex733 == 1) { + Utf8 charSequence733; + Object oldString733 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(733); + if (oldString733 instanceof Utf8) { + charSequence733 = (decoder).readString(((Utf8) oldString733)); + } else { + charSequence733 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(733, charSequence733); + } else { + throw new RuntimeException(("Illegal union index for 'F733': "+ unionIndex733)); + } + } + int unionIndex734 = (decoder.readIndex()); + if (unionIndex734 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(734, null); + } else { + if (unionIndex734 == 1) { + Utf8 charSequence734; + Object oldString734 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(734); + if (oldString734 instanceof Utf8) { + charSequence734 = (decoder).readString(((Utf8) oldString734)); + } else { + charSequence734 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(734, charSequence734); + } else { + throw new RuntimeException(("Illegal union index for 'F734': "+ unionIndex734)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex735 = (decoder.readIndex()); + if (unionIndex735 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(735, null); + } else { + if (unionIndex735 == 1) { + Utf8 charSequence735; + Object oldString735 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(735); + if (oldString735 instanceof Utf8) { + charSequence735 = (decoder).readString(((Utf8) oldString735)); + } else { + charSequence735 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(735, charSequence735); + } else { + throw new RuntimeException(("Illegal union index for 'F735': "+ unionIndex735)); + } + } + int unionIndex736 = (decoder.readIndex()); + if (unionIndex736 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(736, null); + } else { + if (unionIndex736 == 1) { + Utf8 charSequence736; + Object oldString736 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(736); + if (oldString736 instanceof Utf8) { + charSequence736 = (decoder).readString(((Utf8) oldString736)); + } else { + charSequence736 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(736, charSequence736); + } else { + throw new RuntimeException(("Illegal union index for 'F736': "+ unionIndex736)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex737 = (decoder.readIndex()); + if (unionIndex737 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(737, null); + } else { + if (unionIndex737 == 1) { + Utf8 charSequence737; + Object oldString737 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(737); + if (oldString737 instanceof Utf8) { + charSequence737 = (decoder).readString(((Utf8) oldString737)); + } else { + charSequence737 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(737, charSequence737); + } else { + throw new RuntimeException(("Illegal union index for 'F737': "+ unionIndex737)); + } + } + int unionIndex738 = (decoder.readIndex()); + if (unionIndex738 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(738, null); + } else { + if (unionIndex738 == 1) { + Utf8 charSequence738; + Object oldString738 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(738); + if (oldString738 instanceof Utf8) { + charSequence738 = (decoder).readString(((Utf8) oldString738)); + } else { + charSequence738 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(738, charSequence738); + } else { + throw new RuntimeException(("Illegal union index for 'F738': "+ unionIndex738)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex739 = (decoder.readIndex()); + if (unionIndex739 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(739, null); + } else { + if (unionIndex739 == 1) { + Utf8 charSequence739; + Object oldString739 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(739); + if (oldString739 instanceof Utf8) { + charSequence739 = (decoder).readString(((Utf8) oldString739)); + } else { + charSequence739 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(739, charSequence739); + } else { + throw new RuntimeException(("Illegal union index for 'F739': "+ unionIndex739)); + } + } + int unionIndex740 = (decoder.readIndex()); + if (unionIndex740 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(740, null); + } else { + if (unionIndex740 == 1) { + Utf8 charSequence740; + Object oldString740 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(740); + if (oldString740 instanceof Utf8) { + charSequence740 = (decoder).readString(((Utf8) oldString740)); + } else { + charSequence740 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(740, charSequence740); + } else { + throw new RuntimeException(("Illegal union index for 'F740': "+ unionIndex740)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex741 = (decoder.readIndex()); + if (unionIndex741 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(741, null); + } else { + if (unionIndex741 == 1) { + Utf8 charSequence741; + Object oldString741 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(741); + if (oldString741 instanceof Utf8) { + charSequence741 = (decoder).readString(((Utf8) oldString741)); + } else { + charSequence741 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(741, charSequence741); + } else { + throw new RuntimeException(("Illegal union index for 'F741': "+ unionIndex741)); + } + } + int unionIndex742 = (decoder.readIndex()); + if (unionIndex742 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(742, null); + } else { + if (unionIndex742 == 1) { + Utf8 charSequence742; + Object oldString742 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(742); + if (oldString742 instanceof Utf8) { + charSequence742 = (decoder).readString(((Utf8) oldString742)); + } else { + charSequence742 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(742, charSequence742); + } else { + throw new RuntimeException(("Illegal union index for 'F742': "+ unionIndex742)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex743 = (decoder.readIndex()); + if (unionIndex743 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(743, null); + } else { + if (unionIndex743 == 1) { + Utf8 charSequence743; + Object oldString743 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(743); + if (oldString743 instanceof Utf8) { + charSequence743 = (decoder).readString(((Utf8) oldString743)); + } else { + charSequence743 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(743, charSequence743); + } else { + throw new RuntimeException(("Illegal union index for 'F743': "+ unionIndex743)); + } + } + int unionIndex744 = (decoder.readIndex()); + if (unionIndex744 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(744, null); + } else { + if (unionIndex744 == 1) { + Utf8 charSequence744; + Object oldString744 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(744); + if (oldString744 instanceof Utf8) { + charSequence744 = (decoder).readString(((Utf8) oldString744)); + } else { + charSequence744 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(744, charSequence744); + } else { + throw new RuntimeException(("Illegal union index for 'F744': "+ unionIndex744)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex745 = (decoder.readIndex()); + if (unionIndex745 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(745, null); + } else { + if (unionIndex745 == 1) { + Utf8 charSequence745; + Object oldString745 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(745); + if (oldString745 instanceof Utf8) { + charSequence745 = (decoder).readString(((Utf8) oldString745)); + } else { + charSequence745 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(745, charSequence745); + } else { + throw new RuntimeException(("Illegal union index for 'F745': "+ unionIndex745)); + } + } + int unionIndex746 = (decoder.readIndex()); + if (unionIndex746 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(746, null); + } else { + if (unionIndex746 == 1) { + Utf8 charSequence746; + Object oldString746 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(746); + if (oldString746 instanceof Utf8) { + charSequence746 = (decoder).readString(((Utf8) oldString746)); + } else { + charSequence746 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(746, charSequence746); + } else { + throw new RuntimeException(("Illegal union index for 'F746': "+ unionIndex746)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex747 = (decoder.readIndex()); + if (unionIndex747 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(747, null); + } else { + if (unionIndex747 == 1) { + Utf8 charSequence747; + Object oldString747 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(747); + if (oldString747 instanceof Utf8) { + charSequence747 = (decoder).readString(((Utf8) oldString747)); + } else { + charSequence747 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(747, charSequence747); + } else { + throw new RuntimeException(("Illegal union index for 'F747': "+ unionIndex747)); + } + } + int unionIndex748 = (decoder.readIndex()); + if (unionIndex748 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(748, null); + } else { + if (unionIndex748 == 1) { + Utf8 charSequence748; + Object oldString748 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(748); + if (oldString748 instanceof Utf8) { + charSequence748 = (decoder).readString(((Utf8) oldString748)); + } else { + charSequence748 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(748, charSequence748); + } else { + throw new RuntimeException(("Illegal union index for 'F748': "+ unionIndex748)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex749 = (decoder.readIndex()); + if (unionIndex749 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(749, null); + } else { + if (unionIndex749 == 1) { + Utf8 charSequence749; + Object oldString749 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(749); + if (oldString749 instanceof Utf8) { + charSequence749 = (decoder).readString(((Utf8) oldString749)); + } else { + charSequence749 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(749, charSequence749); + } else { + throw new RuntimeException(("Illegal union index for 'F749': "+ unionIndex749)); + } + } + int unionIndex750 = (decoder.readIndex()); + if (unionIndex750 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(750, null); + } else { + if (unionIndex750 == 1) { + Utf8 charSequence750; + Object oldString750 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(750); + if (oldString750 instanceof Utf8) { + charSequence750 = (decoder).readString(((Utf8) oldString750)); + } else { + charSequence750 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(750, charSequence750); + } else { + throw new RuntimeException(("Illegal union index for 'F750': "+ unionIndex750)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex751 = (decoder.readIndex()); + if (unionIndex751 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(751, null); + } else { + if (unionIndex751 == 1) { + Utf8 charSequence751; + Object oldString751 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(751); + if (oldString751 instanceof Utf8) { + charSequence751 = (decoder).readString(((Utf8) oldString751)); + } else { + charSequence751 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(751, charSequence751); + } else { + throw new RuntimeException(("Illegal union index for 'F751': "+ unionIndex751)); + } + } + int unionIndex752 = (decoder.readIndex()); + if (unionIndex752 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(752, null); + } else { + if (unionIndex752 == 1) { + Utf8 charSequence752; + Object oldString752 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(752); + if (oldString752 instanceof Utf8) { + charSequence752 = (decoder).readString(((Utf8) oldString752)); + } else { + charSequence752 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(752, charSequence752); + } else { + throw new RuntimeException(("Illegal union index for 'F752': "+ unionIndex752)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex753 = (decoder.readIndex()); + if (unionIndex753 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(753, null); + } else { + if (unionIndex753 == 1) { + Utf8 charSequence753; + Object oldString753 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(753); + if (oldString753 instanceof Utf8) { + charSequence753 = (decoder).readString(((Utf8) oldString753)); + } else { + charSequence753 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(753, charSequence753); + } else { + throw new RuntimeException(("Illegal union index for 'F753': "+ unionIndex753)); + } + } + int unionIndex754 = (decoder.readIndex()); + if (unionIndex754 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(754, null); + } else { + if (unionIndex754 == 1) { + Utf8 charSequence754; + Object oldString754 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(754); + if (oldString754 instanceof Utf8) { + charSequence754 = (decoder).readString(((Utf8) oldString754)); + } else { + charSequence754 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(754, charSequence754); + } else { + throw new RuntimeException(("Illegal union index for 'F754': "+ unionIndex754)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex755 = (decoder.readIndex()); + if (unionIndex755 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(755, null); + } else { + if (unionIndex755 == 1) { + Utf8 charSequence755; + Object oldString755 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(755); + if (oldString755 instanceof Utf8) { + charSequence755 = (decoder).readString(((Utf8) oldString755)); + } else { + charSequence755 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(755, charSequence755); + } else { + throw new RuntimeException(("Illegal union index for 'F755': "+ unionIndex755)); + } + } + int unionIndex756 = (decoder.readIndex()); + if (unionIndex756 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(756, null); + } else { + if (unionIndex756 == 1) { + Utf8 charSequence756; + Object oldString756 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(756); + if (oldString756 instanceof Utf8) { + charSequence756 = (decoder).readString(((Utf8) oldString756)); + } else { + charSequence756 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(756, charSequence756); + } else { + throw new RuntimeException(("Illegal union index for 'F756': "+ unionIndex756)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex757 = (decoder.readIndex()); + if (unionIndex757 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(757, null); + } else { + if (unionIndex757 == 1) { + Utf8 charSequence757; + Object oldString757 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(757); + if (oldString757 instanceof Utf8) { + charSequence757 = (decoder).readString(((Utf8) oldString757)); + } else { + charSequence757 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(757, charSequence757); + } else { + throw new RuntimeException(("Illegal union index for 'F757': "+ unionIndex757)); + } + } + int unionIndex758 = (decoder.readIndex()); + if (unionIndex758 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(758, null); + } else { + if (unionIndex758 == 1) { + Utf8 charSequence758; + Object oldString758 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(758); + if (oldString758 instanceof Utf8) { + charSequence758 = (decoder).readString(((Utf8) oldString758)); + } else { + charSequence758 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(758, charSequence758); + } else { + throw new RuntimeException(("Illegal union index for 'F758': "+ unionIndex758)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex759 = (decoder.readIndex()); + if (unionIndex759 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(759, null); + } else { + if (unionIndex759 == 1) { + Utf8 charSequence759; + Object oldString759 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(759); + if (oldString759 instanceof Utf8) { + charSequence759 = (decoder).readString(((Utf8) oldString759)); + } else { + charSequence759 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(759, charSequence759); + } else { + throw new RuntimeException(("Illegal union index for 'F759': "+ unionIndex759)); + } + } + int unionIndex760 = (decoder.readIndex()); + if (unionIndex760 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(760, null); + } else { + if (unionIndex760 == 1) { + Utf8 charSequence760; + Object oldString760 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(760); + if (oldString760 instanceof Utf8) { + charSequence760 = (decoder).readString(((Utf8) oldString760)); + } else { + charSequence760 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(760, charSequence760); + } else { + throw new RuntimeException(("Illegal union index for 'F760': "+ unionIndex760)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex761 = (decoder.readIndex()); + if (unionIndex761 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(761, null); + } else { + if (unionIndex761 == 1) { + Utf8 charSequence761; + Object oldString761 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(761); + if (oldString761 instanceof Utf8) { + charSequence761 = (decoder).readString(((Utf8) oldString761)); + } else { + charSequence761 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(761, charSequence761); + } else { + throw new RuntimeException(("Illegal union index for 'F761': "+ unionIndex761)); + } + } + int unionIndex762 = (decoder.readIndex()); + if (unionIndex762 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(762, null); + } else { + if (unionIndex762 == 1) { + Utf8 charSequence762; + Object oldString762 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(762); + if (oldString762 instanceof Utf8) { + charSequence762 = (decoder).readString(((Utf8) oldString762)); + } else { + charSequence762 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(762, charSequence762); + } else { + throw new RuntimeException(("Illegal union index for 'F762': "+ unionIndex762)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex763 = (decoder.readIndex()); + if (unionIndex763 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(763, null); + } else { + if (unionIndex763 == 1) { + Utf8 charSequence763; + Object oldString763 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(763); + if (oldString763 instanceof Utf8) { + charSequence763 = (decoder).readString(((Utf8) oldString763)); + } else { + charSequence763 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(763, charSequence763); + } else { + throw new RuntimeException(("Illegal union index for 'F763': "+ unionIndex763)); + } + } + int unionIndex764 = (decoder.readIndex()); + if (unionIndex764 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(764, null); + } else { + if (unionIndex764 == 1) { + Utf8 charSequence764; + Object oldString764 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(764); + if (oldString764 instanceof Utf8) { + charSequence764 = (decoder).readString(((Utf8) oldString764)); + } else { + charSequence764 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(764, charSequence764); + } else { + throw new RuntimeException(("Illegal union index for 'F764': "+ unionIndex764)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex765 = (decoder.readIndex()); + if (unionIndex765 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(765, null); + } else { + if (unionIndex765 == 1) { + Utf8 charSequence765; + Object oldString765 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(765); + if (oldString765 instanceof Utf8) { + charSequence765 = (decoder).readString(((Utf8) oldString765)); + } else { + charSequence765 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(765, charSequence765); + } else { + throw new RuntimeException(("Illegal union index for 'F765': "+ unionIndex765)); + } + } + int unionIndex766 = (decoder.readIndex()); + if (unionIndex766 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(766, null); + } else { + if (unionIndex766 == 1) { + Utf8 charSequence766; + Object oldString766 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(766); + if (oldString766 instanceof Utf8) { + charSequence766 = (decoder).readString(((Utf8) oldString766)); + } else { + charSequence766 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(766, charSequence766); + } else { + throw new RuntimeException(("Illegal union index for 'F766': "+ unionIndex766)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex767 = (decoder.readIndex()); + if (unionIndex767 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(767, null); + } else { + if (unionIndex767 == 1) { + Utf8 charSequence767; + Object oldString767 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(767); + if (oldString767 instanceof Utf8) { + charSequence767 = (decoder).readString(((Utf8) oldString767)); + } else { + charSequence767 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(767, charSequence767); + } else { + throw new RuntimeException(("Illegal union index for 'F767': "+ unionIndex767)); + } + } + int unionIndex768 = (decoder.readIndex()); + if (unionIndex768 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(768, null); + } else { + if (unionIndex768 == 1) { + Utf8 charSequence768; + Object oldString768 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(768); + if (oldString768 instanceof Utf8) { + charSequence768 = (decoder).readString(((Utf8) oldString768)); + } else { + charSequence768 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(768, charSequence768); + } else { + throw new RuntimeException(("Illegal union index for 'F768': "+ unionIndex768)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex769 = (decoder.readIndex()); + if (unionIndex769 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(769, null); + } else { + if (unionIndex769 == 1) { + Utf8 charSequence769; + Object oldString769 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(769); + if (oldString769 instanceof Utf8) { + charSequence769 = (decoder).readString(((Utf8) oldString769)); + } else { + charSequence769 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(769, charSequence769); + } else { + throw new RuntimeException(("Illegal union index for 'F769': "+ unionIndex769)); + } + } + int unionIndex770 = (decoder.readIndex()); + if (unionIndex770 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(770, null); + } else { + if (unionIndex770 == 1) { + Utf8 charSequence770; + Object oldString770 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(770); + if (oldString770 instanceof Utf8) { + charSequence770 = (decoder).readString(((Utf8) oldString770)); + } else { + charSequence770 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(770, charSequence770); + } else { + throw new RuntimeException(("Illegal union index for 'F770': "+ unionIndex770)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex771 = (decoder.readIndex()); + if (unionIndex771 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(771, null); + } else { + if (unionIndex771 == 1) { + Utf8 charSequence771; + Object oldString771 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(771); + if (oldString771 instanceof Utf8) { + charSequence771 = (decoder).readString(((Utf8) oldString771)); + } else { + charSequence771 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(771, charSequence771); + } else { + throw new RuntimeException(("Illegal union index for 'F771': "+ unionIndex771)); + } + } + int unionIndex772 = (decoder.readIndex()); + if (unionIndex772 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(772, null); + } else { + if (unionIndex772 == 1) { + Utf8 charSequence772; + Object oldString772 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(772); + if (oldString772 instanceof Utf8) { + charSequence772 = (decoder).readString(((Utf8) oldString772)); + } else { + charSequence772 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(772, charSequence772); + } else { + throw new RuntimeException(("Illegal union index for 'F772': "+ unionIndex772)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex773 = (decoder.readIndex()); + if (unionIndex773 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(773, null); + } else { + if (unionIndex773 == 1) { + Utf8 charSequence773; + Object oldString773 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(773); + if (oldString773 instanceof Utf8) { + charSequence773 = (decoder).readString(((Utf8) oldString773)); + } else { + charSequence773 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(773, charSequence773); + } else { + throw new RuntimeException(("Illegal union index for 'F773': "+ unionIndex773)); + } + } + int unionIndex774 = (decoder.readIndex()); + if (unionIndex774 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(774, null); + } else { + if (unionIndex774 == 1) { + Utf8 charSequence774; + Object oldString774 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(774); + if (oldString774 instanceof Utf8) { + charSequence774 = (decoder).readString(((Utf8) oldString774)); + } else { + charSequence774 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(774, charSequence774); + } else { + throw new RuntimeException(("Illegal union index for 'F774': "+ unionIndex774)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex775 = (decoder.readIndex()); + if (unionIndex775 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(775, null); + } else { + if (unionIndex775 == 1) { + Utf8 charSequence775; + Object oldString775 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(775); + if (oldString775 instanceof Utf8) { + charSequence775 = (decoder).readString(((Utf8) oldString775)); + } else { + charSequence775 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(775, charSequence775); + } else { + throw new RuntimeException(("Illegal union index for 'F775': "+ unionIndex775)); + } + } + int unionIndex776 = (decoder.readIndex()); + if (unionIndex776 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(776, null); + } else { + if (unionIndex776 == 1) { + Utf8 charSequence776; + Object oldString776 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(776); + if (oldString776 instanceof Utf8) { + charSequence776 = (decoder).readString(((Utf8) oldString776)); + } else { + charSequence776 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(776, charSequence776); + } else { + throw new RuntimeException(("Illegal union index for 'F776': "+ unionIndex776)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex777 = (decoder.readIndex()); + if (unionIndex777 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(777, null); + } else { + if (unionIndex777 == 1) { + Utf8 charSequence777; + Object oldString777 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(777); + if (oldString777 instanceof Utf8) { + charSequence777 = (decoder).readString(((Utf8) oldString777)); + } else { + charSequence777 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(777, charSequence777); + } else { + throw new RuntimeException(("Illegal union index for 'F777': "+ unionIndex777)); + } + } + int unionIndex778 = (decoder.readIndex()); + if (unionIndex778 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(778, null); + } else { + if (unionIndex778 == 1) { + Utf8 charSequence778; + Object oldString778 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(778); + if (oldString778 instanceof Utf8) { + charSequence778 = (decoder).readString(((Utf8) oldString778)); + } else { + charSequence778 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(778, charSequence778); + } else { + throw new RuntimeException(("Illegal union index for 'F778': "+ unionIndex778)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex779 = (decoder.readIndex()); + if (unionIndex779 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(779, null); + } else { + if (unionIndex779 == 1) { + Utf8 charSequence779; + Object oldString779 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(779); + if (oldString779 instanceof Utf8) { + charSequence779 = (decoder).readString(((Utf8) oldString779)); + } else { + charSequence779 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(779, charSequence779); + } else { + throw new RuntimeException(("Illegal union index for 'F779': "+ unionIndex779)); + } + } + int unionIndex780 = (decoder.readIndex()); + if (unionIndex780 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(780, null); + } else { + if (unionIndex780 == 1) { + Utf8 charSequence780; + Object oldString780 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(780); + if (oldString780 instanceof Utf8) { + charSequence780 = (decoder).readString(((Utf8) oldString780)); + } else { + charSequence780 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(780, charSequence780); + } else { + throw new RuntimeException(("Illegal union index for 'F780': "+ unionIndex780)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex781 = (decoder.readIndex()); + if (unionIndex781 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(781, null); + } else { + if (unionIndex781 == 1) { + Utf8 charSequence781; + Object oldString781 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(781); + if (oldString781 instanceof Utf8) { + charSequence781 = (decoder).readString(((Utf8) oldString781)); + } else { + charSequence781 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(781, charSequence781); + } else { + throw new RuntimeException(("Illegal union index for 'F781': "+ unionIndex781)); + } + } + int unionIndex782 = (decoder.readIndex()); + if (unionIndex782 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(782, null); + } else { + if (unionIndex782 == 1) { + Utf8 charSequence782; + Object oldString782 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(782); + if (oldString782 instanceof Utf8) { + charSequence782 = (decoder).readString(((Utf8) oldString782)); + } else { + charSequence782 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(782, charSequence782); + } else { + throw new RuntimeException(("Illegal union index for 'F782': "+ unionIndex782)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex783 = (decoder.readIndex()); + if (unionIndex783 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(783, null); + } else { + if (unionIndex783 == 1) { + Utf8 charSequence783; + Object oldString783 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(783); + if (oldString783 instanceof Utf8) { + charSequence783 = (decoder).readString(((Utf8) oldString783)); + } else { + charSequence783 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(783, charSequence783); + } else { + throw new RuntimeException(("Illegal union index for 'F783': "+ unionIndex783)); + } + } + int unionIndex784 = (decoder.readIndex()); + if (unionIndex784 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(784, null); + } else { + if (unionIndex784 == 1) { + Utf8 charSequence784; + Object oldString784 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(784); + if (oldString784 instanceof Utf8) { + charSequence784 = (decoder).readString(((Utf8) oldString784)); + } else { + charSequence784 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(784, charSequence784); + } else { + throw new RuntimeException(("Illegal union index for 'F784': "+ unionIndex784)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex785 = (decoder.readIndex()); + if (unionIndex785 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(785, null); + } else { + if (unionIndex785 == 1) { + Utf8 charSequence785; + Object oldString785 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(785); + if (oldString785 instanceof Utf8) { + charSequence785 = (decoder).readString(((Utf8) oldString785)); + } else { + charSequence785 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(785, charSequence785); + } else { + throw new RuntimeException(("Illegal union index for 'F785': "+ unionIndex785)); + } + } + int unionIndex786 = (decoder.readIndex()); + if (unionIndex786 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(786, null); + } else { + if (unionIndex786 == 1) { + Utf8 charSequence786; + Object oldString786 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(786); + if (oldString786 instanceof Utf8) { + charSequence786 = (decoder).readString(((Utf8) oldString786)); + } else { + charSequence786 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(786, charSequence786); + } else { + throw new RuntimeException(("Illegal union index for 'F786': "+ unionIndex786)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex787 = (decoder.readIndex()); + if (unionIndex787 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(787, null); + } else { + if (unionIndex787 == 1) { + Utf8 charSequence787; + Object oldString787 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(787); + if (oldString787 instanceof Utf8) { + charSequence787 = (decoder).readString(((Utf8) oldString787)); + } else { + charSequence787 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(787, charSequence787); + } else { + throw new RuntimeException(("Illegal union index for 'F787': "+ unionIndex787)); + } + } + int unionIndex788 = (decoder.readIndex()); + if (unionIndex788 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(788, null); + } else { + if (unionIndex788 == 1) { + Utf8 charSequence788; + Object oldString788 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(788); + if (oldString788 instanceof Utf8) { + charSequence788 = (decoder).readString(((Utf8) oldString788)); + } else { + charSequence788 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(788, charSequence788); + } else { + throw new RuntimeException(("Illegal union index for 'F788': "+ unionIndex788)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex789 = (decoder.readIndex()); + if (unionIndex789 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(789, null); + } else { + if (unionIndex789 == 1) { + Utf8 charSequence789; + Object oldString789 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(789); + if (oldString789 instanceof Utf8) { + charSequence789 = (decoder).readString(((Utf8) oldString789)); + } else { + charSequence789 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(789, charSequence789); + } else { + throw new RuntimeException(("Illegal union index for 'F789': "+ unionIndex789)); + } + } + int unionIndex790 = (decoder.readIndex()); + if (unionIndex790 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(790, null); + } else { + if (unionIndex790 == 1) { + Utf8 charSequence790; + Object oldString790 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(790); + if (oldString790 instanceof Utf8) { + charSequence790 = (decoder).readString(((Utf8) oldString790)); + } else { + charSequence790 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(790, charSequence790); + } else { + throw new RuntimeException(("Illegal union index for 'F790': "+ unionIndex790)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex791 = (decoder.readIndex()); + if (unionIndex791 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(791, null); + } else { + if (unionIndex791 == 1) { + Utf8 charSequence791; + Object oldString791 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(791); + if (oldString791 instanceof Utf8) { + charSequence791 = (decoder).readString(((Utf8) oldString791)); + } else { + charSequence791 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(791, charSequence791); + } else { + throw new RuntimeException(("Illegal union index for 'F791': "+ unionIndex791)); + } + } + int unionIndex792 = (decoder.readIndex()); + if (unionIndex792 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(792, null); + } else { + if (unionIndex792 == 1) { + Utf8 charSequence792; + Object oldString792 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(792); + if (oldString792 instanceof Utf8) { + charSequence792 = (decoder).readString(((Utf8) oldString792)); + } else { + charSequence792 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(792, charSequence792); + } else { + throw new RuntimeException(("Illegal union index for 'F792': "+ unionIndex792)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex793 = (decoder.readIndex()); + if (unionIndex793 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(793, null); + } else { + if (unionIndex793 == 1) { + Utf8 charSequence793; + Object oldString793 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(793); + if (oldString793 instanceof Utf8) { + charSequence793 = (decoder).readString(((Utf8) oldString793)); + } else { + charSequence793 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(793, charSequence793); + } else { + throw new RuntimeException(("Illegal union index for 'F793': "+ unionIndex793)); + } + } + int unionIndex794 = (decoder.readIndex()); + if (unionIndex794 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(794, null); + } else { + if (unionIndex794 == 1) { + Utf8 charSequence794; + Object oldString794 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(794); + if (oldString794 instanceof Utf8) { + charSequence794 = (decoder).readString(((Utf8) oldString794)); + } else { + charSequence794 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(794, charSequence794); + } else { + throw new RuntimeException(("Illegal union index for 'F794': "+ unionIndex794)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex795 = (decoder.readIndex()); + if (unionIndex795 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(795, null); + } else { + if (unionIndex795 == 1) { + Utf8 charSequence795; + Object oldString795 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(795); + if (oldString795 instanceof Utf8) { + charSequence795 = (decoder).readString(((Utf8) oldString795)); + } else { + charSequence795 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(795, charSequence795); + } else { + throw new RuntimeException(("Illegal union index for 'F795': "+ unionIndex795)); + } + } + int unionIndex796 = (decoder.readIndex()); + if (unionIndex796 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(796, null); + } else { + if (unionIndex796 == 1) { + Utf8 charSequence796; + Object oldString796 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(796); + if (oldString796 instanceof Utf8) { + charSequence796 = (decoder).readString(((Utf8) oldString796)); + } else { + charSequence796 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(796, charSequence796); + } else { + throw new RuntimeException(("Illegal union index for 'F796': "+ unionIndex796)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex797 = (decoder.readIndex()); + if (unionIndex797 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(797, null); + } else { + if (unionIndex797 == 1) { + Utf8 charSequence797; + Object oldString797 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(797); + if (oldString797 instanceof Utf8) { + charSequence797 = (decoder).readString(((Utf8) oldString797)); + } else { + charSequence797 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(797, charSequence797); + } else { + throw new RuntimeException(("Illegal union index for 'F797': "+ unionIndex797)); + } + } + int unionIndex798 = (decoder.readIndex()); + if (unionIndex798 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(798, null); + } else { + if (unionIndex798 == 1) { + Utf8 charSequence798; + Object oldString798 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(798); + if (oldString798 instanceof Utf8) { + charSequence798 = (decoder).readString(((Utf8) oldString798)); + } else { + charSequence798 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(798, charSequence798); + } else { + throw new RuntimeException(("Illegal union index for 'F798': "+ unionIndex798)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex799 = (decoder.readIndex()); + if (unionIndex799 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(799, null); + } else { + if (unionIndex799 == 1) { + Utf8 charSequence799; + Object oldString799 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(799); + if (oldString799 instanceof Utf8) { + charSequence799 = (decoder).readString(((Utf8) oldString799)); + } else { + charSequence799 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(799, charSequence799); + } else { + throw new RuntimeException(("Illegal union index for 'F799': "+ unionIndex799)); + } + } + int unionIndex800 = (decoder.readIndex()); + if (unionIndex800 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(800, null); + } else { + if (unionIndex800 == 1) { + Utf8 charSequence800; + Object oldString800 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(800); + if (oldString800 instanceof Utf8) { + charSequence800 = (decoder).readString(((Utf8) oldString800)); + } else { + charSequence800 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(800, charSequence800); + } else { + throw new RuntimeException(("Illegal union index for 'F800': "+ unionIndex800)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex801 = (decoder.readIndex()); + if (unionIndex801 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(801, null); + } else { + if (unionIndex801 == 1) { + Utf8 charSequence801; + Object oldString801 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(801); + if (oldString801 instanceof Utf8) { + charSequence801 = (decoder).readString(((Utf8) oldString801)); + } else { + charSequence801 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(801, charSequence801); + } else { + throw new RuntimeException(("Illegal union index for 'F801': "+ unionIndex801)); + } + } + int unionIndex802 = (decoder.readIndex()); + if (unionIndex802 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(802, null); + } else { + if (unionIndex802 == 1) { + Utf8 charSequence802; + Object oldString802 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(802); + if (oldString802 instanceof Utf8) { + charSequence802 = (decoder).readString(((Utf8) oldString802)); + } else { + charSequence802 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(802, charSequence802); + } else { + throw new RuntimeException(("Illegal union index for 'F802': "+ unionIndex802)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex803 = (decoder.readIndex()); + if (unionIndex803 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(803, null); + } else { + if (unionIndex803 == 1) { + Utf8 charSequence803; + Object oldString803 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(803); + if (oldString803 instanceof Utf8) { + charSequence803 = (decoder).readString(((Utf8) oldString803)); + } else { + charSequence803 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(803, charSequence803); + } else { + throw new RuntimeException(("Illegal union index for 'F803': "+ unionIndex803)); + } + } + int unionIndex804 = (decoder.readIndex()); + if (unionIndex804 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(804, null); + } else { + if (unionIndex804 == 1) { + Utf8 charSequence804; + Object oldString804 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(804); + if (oldString804 instanceof Utf8) { + charSequence804 = (decoder).readString(((Utf8) oldString804)); + } else { + charSequence804 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(804, charSequence804); + } else { + throw new RuntimeException(("Illegal union index for 'F804': "+ unionIndex804)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex805 = (decoder.readIndex()); + if (unionIndex805 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(805, null); + } else { + if (unionIndex805 == 1) { + Utf8 charSequence805; + Object oldString805 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(805); + if (oldString805 instanceof Utf8) { + charSequence805 = (decoder).readString(((Utf8) oldString805)); + } else { + charSequence805 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(805, charSequence805); + } else { + throw new RuntimeException(("Illegal union index for 'F805': "+ unionIndex805)); + } + } + int unionIndex806 = (decoder.readIndex()); + if (unionIndex806 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(806, null); + } else { + if (unionIndex806 == 1) { + Utf8 charSequence806; + Object oldString806 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(806); + if (oldString806 instanceof Utf8) { + charSequence806 = (decoder).readString(((Utf8) oldString806)); + } else { + charSequence806 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(806, charSequence806); + } else { + throw new RuntimeException(("Illegal union index for 'F806': "+ unionIndex806)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex807 = (decoder.readIndex()); + if (unionIndex807 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(807, null); + } else { + if (unionIndex807 == 1) { + Utf8 charSequence807; + Object oldString807 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(807); + if (oldString807 instanceof Utf8) { + charSequence807 = (decoder).readString(((Utf8) oldString807)); + } else { + charSequence807 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(807, charSequence807); + } else { + throw new RuntimeException(("Illegal union index for 'F807': "+ unionIndex807)); + } + } + int unionIndex808 = (decoder.readIndex()); + if (unionIndex808 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(808, null); + } else { + if (unionIndex808 == 1) { + Utf8 charSequence808; + Object oldString808 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(808); + if (oldString808 instanceof Utf8) { + charSequence808 = (decoder).readString(((Utf8) oldString808)); + } else { + charSequence808 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(808, charSequence808); + } else { + throw new RuntimeException(("Illegal union index for 'F808': "+ unionIndex808)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex809 = (decoder.readIndex()); + if (unionIndex809 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(809, null); + } else { + if (unionIndex809 == 1) { + Utf8 charSequence809; + Object oldString809 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(809); + if (oldString809 instanceof Utf8) { + charSequence809 = (decoder).readString(((Utf8) oldString809)); + } else { + charSequence809 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(809, charSequence809); + } else { + throw new RuntimeException(("Illegal union index for 'F809': "+ unionIndex809)); + } + } + int unionIndex810 = (decoder.readIndex()); + if (unionIndex810 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(810, null); + } else { + if (unionIndex810 == 1) { + Utf8 charSequence810; + Object oldString810 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(810); + if (oldString810 instanceof Utf8) { + charSequence810 = (decoder).readString(((Utf8) oldString810)); + } else { + charSequence810 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(810, charSequence810); + } else { + throw new RuntimeException(("Illegal union index for 'F810': "+ unionIndex810)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex811 = (decoder.readIndex()); + if (unionIndex811 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(811, null); + } else { + if (unionIndex811 == 1) { + Utf8 charSequence811; + Object oldString811 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(811); + if (oldString811 instanceof Utf8) { + charSequence811 = (decoder).readString(((Utf8) oldString811)); + } else { + charSequence811 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(811, charSequence811); + } else { + throw new RuntimeException(("Illegal union index for 'F811': "+ unionIndex811)); + } + } + int unionIndex812 = (decoder.readIndex()); + if (unionIndex812 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(812, null); + } else { + if (unionIndex812 == 1) { + Utf8 charSequence812; + Object oldString812 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(812); + if (oldString812 instanceof Utf8) { + charSequence812 = (decoder).readString(((Utf8) oldString812)); + } else { + charSequence812 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(812, charSequence812); + } else { + throw new RuntimeException(("Illegal union index for 'F812': "+ unionIndex812)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex813 = (decoder.readIndex()); + if (unionIndex813 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(813, null); + } else { + if (unionIndex813 == 1) { + Utf8 charSequence813; + Object oldString813 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(813); + if (oldString813 instanceof Utf8) { + charSequence813 = (decoder).readString(((Utf8) oldString813)); + } else { + charSequence813 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(813, charSequence813); + } else { + throw new RuntimeException(("Illegal union index for 'F813': "+ unionIndex813)); + } + } + int unionIndex814 = (decoder.readIndex()); + if (unionIndex814 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(814, null); + } else { + if (unionIndex814 == 1) { + Utf8 charSequence814; + Object oldString814 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(814); + if (oldString814 instanceof Utf8) { + charSequence814 = (decoder).readString(((Utf8) oldString814)); + } else { + charSequence814 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(814, charSequence814); + } else { + throw new RuntimeException(("Illegal union index for 'F814': "+ unionIndex814)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex815 = (decoder.readIndex()); + if (unionIndex815 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(815, null); + } else { + if (unionIndex815 == 1) { + Utf8 charSequence815; + Object oldString815 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(815); + if (oldString815 instanceof Utf8) { + charSequence815 = (decoder).readString(((Utf8) oldString815)); + } else { + charSequence815 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(815, charSequence815); + } else { + throw new RuntimeException(("Illegal union index for 'F815': "+ unionIndex815)); + } + } + int unionIndex816 = (decoder.readIndex()); + if (unionIndex816 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(816, null); + } else { + if (unionIndex816 == 1) { + Utf8 charSequence816; + Object oldString816 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(816); + if (oldString816 instanceof Utf8) { + charSequence816 = (decoder).readString(((Utf8) oldString816)); + } else { + charSequence816 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(816, charSequence816); + } else { + throw new RuntimeException(("Illegal union index for 'F816': "+ unionIndex816)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex817 = (decoder.readIndex()); + if (unionIndex817 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(817, null); + } else { + if (unionIndex817 == 1) { + Utf8 charSequence817; + Object oldString817 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(817); + if (oldString817 instanceof Utf8) { + charSequence817 = (decoder).readString(((Utf8) oldString817)); + } else { + charSequence817 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(817, charSequence817); + } else { + throw new RuntimeException(("Illegal union index for 'F817': "+ unionIndex817)); + } + } + int unionIndex818 = (decoder.readIndex()); + if (unionIndex818 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(818, null); + } else { + if (unionIndex818 == 1) { + Utf8 charSequence818; + Object oldString818 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(818); + if (oldString818 instanceof Utf8) { + charSequence818 = (decoder).readString(((Utf8) oldString818)); + } else { + charSequence818 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(818, charSequence818); + } else { + throw new RuntimeException(("Illegal union index for 'F818': "+ unionIndex818)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex819 = (decoder.readIndex()); + if (unionIndex819 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(819, null); + } else { + if (unionIndex819 == 1) { + Utf8 charSequence819; + Object oldString819 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(819); + if (oldString819 instanceof Utf8) { + charSequence819 = (decoder).readString(((Utf8) oldString819)); + } else { + charSequence819 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(819, charSequence819); + } else { + throw new RuntimeException(("Illegal union index for 'F819': "+ unionIndex819)); + } + } + int unionIndex820 = (decoder.readIndex()); + if (unionIndex820 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(820, null); + } else { + if (unionIndex820 == 1) { + Utf8 charSequence820; + Object oldString820 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(820); + if (oldString820 instanceof Utf8) { + charSequence820 = (decoder).readString(((Utf8) oldString820)); + } else { + charSequence820 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(820, charSequence820); + } else { + throw new RuntimeException(("Illegal union index for 'F820': "+ unionIndex820)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex821 = (decoder.readIndex()); + if (unionIndex821 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(821, null); + } else { + if (unionIndex821 == 1) { + Utf8 charSequence821; + Object oldString821 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(821); + if (oldString821 instanceof Utf8) { + charSequence821 = (decoder).readString(((Utf8) oldString821)); + } else { + charSequence821 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(821, charSequence821); + } else { + throw new RuntimeException(("Illegal union index for 'F821': "+ unionIndex821)); + } + } + int unionIndex822 = (decoder.readIndex()); + if (unionIndex822 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(822, null); + } else { + if (unionIndex822 == 1) { + Utf8 charSequence822; + Object oldString822 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(822); + if (oldString822 instanceof Utf8) { + charSequence822 = (decoder).readString(((Utf8) oldString822)); + } else { + charSequence822 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(822, charSequence822); + } else { + throw new RuntimeException(("Illegal union index for 'F822': "+ unionIndex822)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex823 = (decoder.readIndex()); + if (unionIndex823 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(823, null); + } else { + if (unionIndex823 == 1) { + Utf8 charSequence823; + Object oldString823 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(823); + if (oldString823 instanceof Utf8) { + charSequence823 = (decoder).readString(((Utf8) oldString823)); + } else { + charSequence823 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(823, charSequence823); + } else { + throw new RuntimeException(("Illegal union index for 'F823': "+ unionIndex823)); + } + } + int unionIndex824 = (decoder.readIndex()); + if (unionIndex824 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(824, null); + } else { + if (unionIndex824 == 1) { + Utf8 charSequence824; + Object oldString824 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(824); + if (oldString824 instanceof Utf8) { + charSequence824 = (decoder).readString(((Utf8) oldString824)); + } else { + charSequence824 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(824, charSequence824); + } else { + throw new RuntimeException(("Illegal union index for 'F824': "+ unionIndex824)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex825 = (decoder.readIndex()); + if (unionIndex825 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(825, null); + } else { + if (unionIndex825 == 1) { + Utf8 charSequence825; + Object oldString825 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(825); + if (oldString825 instanceof Utf8) { + charSequence825 = (decoder).readString(((Utf8) oldString825)); + } else { + charSequence825 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(825, charSequence825); + } else { + throw new RuntimeException(("Illegal union index for 'F825': "+ unionIndex825)); + } + } + int unionIndex826 = (decoder.readIndex()); + if (unionIndex826 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(826, null); + } else { + if (unionIndex826 == 1) { + Utf8 charSequence826; + Object oldString826 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(826); + if (oldString826 instanceof Utf8) { + charSequence826 = (decoder).readString(((Utf8) oldString826)); + } else { + charSequence826 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(826, charSequence826); + } else { + throw new RuntimeException(("Illegal union index for 'F826': "+ unionIndex826)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex827 = (decoder.readIndex()); + if (unionIndex827 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(827, null); + } else { + if (unionIndex827 == 1) { + Utf8 charSequence827; + Object oldString827 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(827); + if (oldString827 instanceof Utf8) { + charSequence827 = (decoder).readString(((Utf8) oldString827)); + } else { + charSequence827 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(827, charSequence827); + } else { + throw new RuntimeException(("Illegal union index for 'F827': "+ unionIndex827)); + } + } + int unionIndex828 = (decoder.readIndex()); + if (unionIndex828 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(828, null); + } else { + if (unionIndex828 == 1) { + Utf8 charSequence828; + Object oldString828 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(828); + if (oldString828 instanceof Utf8) { + charSequence828 = (decoder).readString(((Utf8) oldString828)); + } else { + charSequence828 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(828, charSequence828); + } else { + throw new RuntimeException(("Illegal union index for 'F828': "+ unionIndex828)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex829 = (decoder.readIndex()); + if (unionIndex829 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(829, null); + } else { + if (unionIndex829 == 1) { + Utf8 charSequence829; + Object oldString829 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(829); + if (oldString829 instanceof Utf8) { + charSequence829 = (decoder).readString(((Utf8) oldString829)); + } else { + charSequence829 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(829, charSequence829); + } else { + throw new RuntimeException(("Illegal union index for 'F829': "+ unionIndex829)); + } + } + int unionIndex830 = (decoder.readIndex()); + if (unionIndex830 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(830, null); + } else { + if (unionIndex830 == 1) { + Utf8 charSequence830; + Object oldString830 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(830); + if (oldString830 instanceof Utf8) { + charSequence830 = (decoder).readString(((Utf8) oldString830)); + } else { + charSequence830 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(830, charSequence830); + } else { + throw new RuntimeException(("Illegal union index for 'F830': "+ unionIndex830)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex831 = (decoder.readIndex()); + if (unionIndex831 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(831, null); + } else { + if (unionIndex831 == 1) { + Utf8 charSequence831; + Object oldString831 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(831); + if (oldString831 instanceof Utf8) { + charSequence831 = (decoder).readString(((Utf8) oldString831)); + } else { + charSequence831 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(831, charSequence831); + } else { + throw new RuntimeException(("Illegal union index for 'F831': "+ unionIndex831)); + } + } + int unionIndex832 = (decoder.readIndex()); + if (unionIndex832 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(832, null); + } else { + if (unionIndex832 == 1) { + Utf8 charSequence832; + Object oldString832 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(832); + if (oldString832 instanceof Utf8) { + charSequence832 = (decoder).readString(((Utf8) oldString832)); + } else { + charSequence832 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(832, charSequence832); + } else { + throw new RuntimeException(("Illegal union index for 'F832': "+ unionIndex832)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex833 = (decoder.readIndex()); + if (unionIndex833 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(833, null); + } else { + if (unionIndex833 == 1) { + Utf8 charSequence833; + Object oldString833 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(833); + if (oldString833 instanceof Utf8) { + charSequence833 = (decoder).readString(((Utf8) oldString833)); + } else { + charSequence833 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(833, charSequence833); + } else { + throw new RuntimeException(("Illegal union index for 'F833': "+ unionIndex833)); + } + } + int unionIndex834 = (decoder.readIndex()); + if (unionIndex834 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(834, null); + } else { + if (unionIndex834 == 1) { + Utf8 charSequence834; + Object oldString834 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(834); + if (oldString834 instanceof Utf8) { + charSequence834 = (decoder).readString(((Utf8) oldString834)); + } else { + charSequence834 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(834, charSequence834); + } else { + throw new RuntimeException(("Illegal union index for 'F834': "+ unionIndex834)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex835 = (decoder.readIndex()); + if (unionIndex835 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(835, null); + } else { + if (unionIndex835 == 1) { + Utf8 charSequence835; + Object oldString835 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(835); + if (oldString835 instanceof Utf8) { + charSequence835 = (decoder).readString(((Utf8) oldString835)); + } else { + charSequence835 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(835, charSequence835); + } else { + throw new RuntimeException(("Illegal union index for 'F835': "+ unionIndex835)); + } + } + int unionIndex836 = (decoder.readIndex()); + if (unionIndex836 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(836, null); + } else { + if (unionIndex836 == 1) { + Utf8 charSequence836; + Object oldString836 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(836); + if (oldString836 instanceof Utf8) { + charSequence836 = (decoder).readString(((Utf8) oldString836)); + } else { + charSequence836 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(836, charSequence836); + } else { + throw new RuntimeException(("Illegal union index for 'F836': "+ unionIndex836)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex837 = (decoder.readIndex()); + if (unionIndex837 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(837, null); + } else { + if (unionIndex837 == 1) { + Utf8 charSequence837; + Object oldString837 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(837); + if (oldString837 instanceof Utf8) { + charSequence837 = (decoder).readString(((Utf8) oldString837)); + } else { + charSequence837 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(837, charSequence837); + } else { + throw new RuntimeException(("Illegal union index for 'F837': "+ unionIndex837)); + } + } + int unionIndex838 = (decoder.readIndex()); + if (unionIndex838 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(838, null); + } else { + if (unionIndex838 == 1) { + Utf8 charSequence838; + Object oldString838 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(838); + if (oldString838 instanceof Utf8) { + charSequence838 = (decoder).readString(((Utf8) oldString838)); + } else { + charSequence838 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(838, charSequence838); + } else { + throw new RuntimeException(("Illegal union index for 'F838': "+ unionIndex838)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex839 = (decoder.readIndex()); + if (unionIndex839 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(839, null); + } else { + if (unionIndex839 == 1) { + Utf8 charSequence839; + Object oldString839 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(839); + if (oldString839 instanceof Utf8) { + charSequence839 = (decoder).readString(((Utf8) oldString839)); + } else { + charSequence839 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(839, charSequence839); + } else { + throw new RuntimeException(("Illegal union index for 'F839': "+ unionIndex839)); + } + } + int unionIndex840 = (decoder.readIndex()); + if (unionIndex840 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(840, null); + } else { + if (unionIndex840 == 1) { + Utf8 charSequence840; + Object oldString840 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(840); + if (oldString840 instanceof Utf8) { + charSequence840 = (decoder).readString(((Utf8) oldString840)); + } else { + charSequence840 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(840, charSequence840); + } else { + throw new RuntimeException(("Illegal union index for 'F840': "+ unionIndex840)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex841 = (decoder.readIndex()); + if (unionIndex841 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(841, null); + } else { + if (unionIndex841 == 1) { + Utf8 charSequence841; + Object oldString841 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(841); + if (oldString841 instanceof Utf8) { + charSequence841 = (decoder).readString(((Utf8) oldString841)); + } else { + charSequence841 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(841, charSequence841); + } else { + throw new RuntimeException(("Illegal union index for 'F841': "+ unionIndex841)); + } + } + int unionIndex842 = (decoder.readIndex()); + if (unionIndex842 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(842, null); + } else { + if (unionIndex842 == 1) { + Utf8 charSequence842; + Object oldString842 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(842); + if (oldString842 instanceof Utf8) { + charSequence842 = (decoder).readString(((Utf8) oldString842)); + } else { + charSequence842 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(842, charSequence842); + } else { + throw new RuntimeException(("Illegal union index for 'F842': "+ unionIndex842)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex843 = (decoder.readIndex()); + if (unionIndex843 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(843, null); + } else { + if (unionIndex843 == 1) { + Utf8 charSequence843; + Object oldString843 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(843); + if (oldString843 instanceof Utf8) { + charSequence843 = (decoder).readString(((Utf8) oldString843)); + } else { + charSequence843 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(843, charSequence843); + } else { + throw new RuntimeException(("Illegal union index for 'F843': "+ unionIndex843)); + } + } + int unionIndex844 = (decoder.readIndex()); + if (unionIndex844 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(844, null); + } else { + if (unionIndex844 == 1) { + Utf8 charSequence844; + Object oldString844 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(844); + if (oldString844 instanceof Utf8) { + charSequence844 = (decoder).readString(((Utf8) oldString844)); + } else { + charSequence844 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(844, charSequence844); + } else { + throw new RuntimeException(("Illegal union index for 'F844': "+ unionIndex844)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex845 = (decoder.readIndex()); + if (unionIndex845 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(845, null); + } else { + if (unionIndex845 == 1) { + Utf8 charSequence845; + Object oldString845 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(845); + if (oldString845 instanceof Utf8) { + charSequence845 = (decoder).readString(((Utf8) oldString845)); + } else { + charSequence845 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(845, charSequence845); + } else { + throw new RuntimeException(("Illegal union index for 'F845': "+ unionIndex845)); + } + } + int unionIndex846 = (decoder.readIndex()); + if (unionIndex846 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(846, null); + } else { + if (unionIndex846 == 1) { + Utf8 charSequence846; + Object oldString846 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(846); + if (oldString846 instanceof Utf8) { + charSequence846 = (decoder).readString(((Utf8) oldString846)); + } else { + charSequence846 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(846, charSequence846); + } else { + throw new RuntimeException(("Illegal union index for 'F846': "+ unionIndex846)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex847 = (decoder.readIndex()); + if (unionIndex847 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(847, null); + } else { + if (unionIndex847 == 1) { + Utf8 charSequence847; + Object oldString847 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(847); + if (oldString847 instanceof Utf8) { + charSequence847 = (decoder).readString(((Utf8) oldString847)); + } else { + charSequence847 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(847, charSequence847); + } else { + throw new RuntimeException(("Illegal union index for 'F847': "+ unionIndex847)); + } + } + int unionIndex848 = (decoder.readIndex()); + if (unionIndex848 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(848, null); + } else { + if (unionIndex848 == 1) { + Utf8 charSequence848; + Object oldString848 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(848); + if (oldString848 instanceof Utf8) { + charSequence848 = (decoder).readString(((Utf8) oldString848)); + } else { + charSequence848 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(848, charSequence848); + } else { + throw new RuntimeException(("Illegal union index for 'F848': "+ unionIndex848)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex849 = (decoder.readIndex()); + if (unionIndex849 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(849, null); + } else { + if (unionIndex849 == 1) { + Utf8 charSequence849; + Object oldString849 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(849); + if (oldString849 instanceof Utf8) { + charSequence849 = (decoder).readString(((Utf8) oldString849)); + } else { + charSequence849 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(849, charSequence849); + } else { + throw new RuntimeException(("Illegal union index for 'F849': "+ unionIndex849)); + } + } + int unionIndex850 = (decoder.readIndex()); + if (unionIndex850 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(850, null); + } else { + if (unionIndex850 == 1) { + Utf8 charSequence850; + Object oldString850 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(850); + if (oldString850 instanceof Utf8) { + charSequence850 = (decoder).readString(((Utf8) oldString850)); + } else { + charSequence850 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(850, charSequence850); + } else { + throw new RuntimeException(("Illegal union index for 'F850': "+ unionIndex850)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex851 = (decoder.readIndex()); + if (unionIndex851 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(851, null); + } else { + if (unionIndex851 == 1) { + Utf8 charSequence851; + Object oldString851 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(851); + if (oldString851 instanceof Utf8) { + charSequence851 = (decoder).readString(((Utf8) oldString851)); + } else { + charSequence851 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(851, charSequence851); + } else { + throw new RuntimeException(("Illegal union index for 'F851': "+ unionIndex851)); + } + } + int unionIndex852 = (decoder.readIndex()); + if (unionIndex852 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(852, null); + } else { + if (unionIndex852 == 1) { + Utf8 charSequence852; + Object oldString852 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(852); + if (oldString852 instanceof Utf8) { + charSequence852 = (decoder).readString(((Utf8) oldString852)); + } else { + charSequence852 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(852, charSequence852); + } else { + throw new RuntimeException(("Illegal union index for 'F852': "+ unionIndex852)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex853 = (decoder.readIndex()); + if (unionIndex853 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(853, null); + } else { + if (unionIndex853 == 1) { + Utf8 charSequence853; + Object oldString853 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(853); + if (oldString853 instanceof Utf8) { + charSequence853 = (decoder).readString(((Utf8) oldString853)); + } else { + charSequence853 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(853, charSequence853); + } else { + throw new RuntimeException(("Illegal union index for 'F853': "+ unionIndex853)); + } + } + int unionIndex854 = (decoder.readIndex()); + if (unionIndex854 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(854, null); + } else { + if (unionIndex854 == 1) { + Utf8 charSequence854; + Object oldString854 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(854); + if (oldString854 instanceof Utf8) { + charSequence854 = (decoder).readString(((Utf8) oldString854)); + } else { + charSequence854 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(854, charSequence854); + } else { + throw new RuntimeException(("Illegal union index for 'F854': "+ unionIndex854)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex855 = (decoder.readIndex()); + if (unionIndex855 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(855, null); + } else { + if (unionIndex855 == 1) { + Utf8 charSequence855; + Object oldString855 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(855); + if (oldString855 instanceof Utf8) { + charSequence855 = (decoder).readString(((Utf8) oldString855)); + } else { + charSequence855 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(855, charSequence855); + } else { + throw new RuntimeException(("Illegal union index for 'F855': "+ unionIndex855)); + } + } + int unionIndex856 = (decoder.readIndex()); + if (unionIndex856 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(856, null); + } else { + if (unionIndex856 == 1) { + Utf8 charSequence856; + Object oldString856 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(856); + if (oldString856 instanceof Utf8) { + charSequence856 = (decoder).readString(((Utf8) oldString856)); + } else { + charSequence856 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(856, charSequence856); + } else { + throw new RuntimeException(("Illegal union index for 'F856': "+ unionIndex856)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex857 = (decoder.readIndex()); + if (unionIndex857 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(857, null); + } else { + if (unionIndex857 == 1) { + Utf8 charSequence857; + Object oldString857 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(857); + if (oldString857 instanceof Utf8) { + charSequence857 = (decoder).readString(((Utf8) oldString857)); + } else { + charSequence857 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(857, charSequence857); + } else { + throw new RuntimeException(("Illegal union index for 'F857': "+ unionIndex857)); + } + } + int unionIndex858 = (decoder.readIndex()); + if (unionIndex858 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(858, null); + } else { + if (unionIndex858 == 1) { + Utf8 charSequence858; + Object oldString858 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(858); + if (oldString858 instanceof Utf8) { + charSequence858 = (decoder).readString(((Utf8) oldString858)); + } else { + charSequence858 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(858, charSequence858); + } else { + throw new RuntimeException(("Illegal union index for 'F858': "+ unionIndex858)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex859 = (decoder.readIndex()); + if (unionIndex859 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(859, null); + } else { + if (unionIndex859 == 1) { + Utf8 charSequence859; + Object oldString859 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(859); + if (oldString859 instanceof Utf8) { + charSequence859 = (decoder).readString(((Utf8) oldString859)); + } else { + charSequence859 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(859, charSequence859); + } else { + throw new RuntimeException(("Illegal union index for 'F859': "+ unionIndex859)); + } + } + int unionIndex860 = (decoder.readIndex()); + if (unionIndex860 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(860, null); + } else { + if (unionIndex860 == 1) { + Utf8 charSequence860; + Object oldString860 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(860); + if (oldString860 instanceof Utf8) { + charSequence860 = (decoder).readString(((Utf8) oldString860)); + } else { + charSequence860 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(860, charSequence860); + } else { + throw new RuntimeException(("Illegal union index for 'F860': "+ unionIndex860)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex861 = (decoder.readIndex()); + if (unionIndex861 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(861, null); + } else { + if (unionIndex861 == 1) { + Utf8 charSequence861; + Object oldString861 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(861); + if (oldString861 instanceof Utf8) { + charSequence861 = (decoder).readString(((Utf8) oldString861)); + } else { + charSequence861 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(861, charSequence861); + } else { + throw new RuntimeException(("Illegal union index for 'F861': "+ unionIndex861)); + } + } + int unionIndex862 = (decoder.readIndex()); + if (unionIndex862 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(862, null); + } else { + if (unionIndex862 == 1) { + Utf8 charSequence862; + Object oldString862 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(862); + if (oldString862 instanceof Utf8) { + charSequence862 = (decoder).readString(((Utf8) oldString862)); + } else { + charSequence862 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(862, charSequence862); + } else { + throw new RuntimeException(("Illegal union index for 'F862': "+ unionIndex862)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex863 = (decoder.readIndex()); + if (unionIndex863 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(863, null); + } else { + if (unionIndex863 == 1) { + Utf8 charSequence863; + Object oldString863 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(863); + if (oldString863 instanceof Utf8) { + charSequence863 = (decoder).readString(((Utf8) oldString863)); + } else { + charSequence863 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(863, charSequence863); + } else { + throw new RuntimeException(("Illegal union index for 'F863': "+ unionIndex863)); + } + } + int unionIndex864 = (decoder.readIndex()); + if (unionIndex864 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(864, null); + } else { + if (unionIndex864 == 1) { + Utf8 charSequence864; + Object oldString864 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(864); + if (oldString864 instanceof Utf8) { + charSequence864 = (decoder).readString(((Utf8) oldString864)); + } else { + charSequence864 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(864, charSequence864); + } else { + throw new RuntimeException(("Illegal union index for 'F864': "+ unionIndex864)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex865 = (decoder.readIndex()); + if (unionIndex865 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(865, null); + } else { + if (unionIndex865 == 1) { + Utf8 charSequence865; + Object oldString865 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(865); + if (oldString865 instanceof Utf8) { + charSequence865 = (decoder).readString(((Utf8) oldString865)); + } else { + charSequence865 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(865, charSequence865); + } else { + throw new RuntimeException(("Illegal union index for 'F865': "+ unionIndex865)); + } + } + int unionIndex866 = (decoder.readIndex()); + if (unionIndex866 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(866, null); + } else { + if (unionIndex866 == 1) { + Utf8 charSequence866; + Object oldString866 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(866); + if (oldString866 instanceof Utf8) { + charSequence866 = (decoder).readString(((Utf8) oldString866)); + } else { + charSequence866 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(866, charSequence866); + } else { + throw new RuntimeException(("Illegal union index for 'F866': "+ unionIndex866)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex867 = (decoder.readIndex()); + if (unionIndex867 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(867, null); + } else { + if (unionIndex867 == 1) { + Utf8 charSequence867; + Object oldString867 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(867); + if (oldString867 instanceof Utf8) { + charSequence867 = (decoder).readString(((Utf8) oldString867)); + } else { + charSequence867 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(867, charSequence867); + } else { + throw new RuntimeException(("Illegal union index for 'F867': "+ unionIndex867)); + } + } + int unionIndex868 = (decoder.readIndex()); + if (unionIndex868 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(868, null); + } else { + if (unionIndex868 == 1) { + Utf8 charSequence868; + Object oldString868 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(868); + if (oldString868 instanceof Utf8) { + charSequence868 = (decoder).readString(((Utf8) oldString868)); + } else { + charSequence868 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(868, charSequence868); + } else { + throw new RuntimeException(("Illegal union index for 'F868': "+ unionIndex868)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex869 = (decoder.readIndex()); + if (unionIndex869 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(869, null); + } else { + if (unionIndex869 == 1) { + Utf8 charSequence869; + Object oldString869 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(869); + if (oldString869 instanceof Utf8) { + charSequence869 = (decoder).readString(((Utf8) oldString869)); + } else { + charSequence869 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(869, charSequence869); + } else { + throw new RuntimeException(("Illegal union index for 'F869': "+ unionIndex869)); + } + } + int unionIndex870 = (decoder.readIndex()); + if (unionIndex870 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(870, null); + } else { + if (unionIndex870 == 1) { + Utf8 charSequence870; + Object oldString870 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(870); + if (oldString870 instanceof Utf8) { + charSequence870 = (decoder).readString(((Utf8) oldString870)); + } else { + charSequence870 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(870, charSequence870); + } else { + throw new RuntimeException(("Illegal union index for 'F870': "+ unionIndex870)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex871 = (decoder.readIndex()); + if (unionIndex871 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(871, null); + } else { + if (unionIndex871 == 1) { + Utf8 charSequence871; + Object oldString871 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(871); + if (oldString871 instanceof Utf8) { + charSequence871 = (decoder).readString(((Utf8) oldString871)); + } else { + charSequence871 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(871, charSequence871); + } else { + throw new RuntimeException(("Illegal union index for 'F871': "+ unionIndex871)); + } + } + int unionIndex872 = (decoder.readIndex()); + if (unionIndex872 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(872, null); + } else { + if (unionIndex872 == 1) { + Utf8 charSequence872; + Object oldString872 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(872); + if (oldString872 instanceof Utf8) { + charSequence872 = (decoder).readString(((Utf8) oldString872)); + } else { + charSequence872 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(872, charSequence872); + } else { + throw new RuntimeException(("Illegal union index for 'F872': "+ unionIndex872)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex873 = (decoder.readIndex()); + if (unionIndex873 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(873, null); + } else { + if (unionIndex873 == 1) { + Utf8 charSequence873; + Object oldString873 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(873); + if (oldString873 instanceof Utf8) { + charSequence873 = (decoder).readString(((Utf8) oldString873)); + } else { + charSequence873 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(873, charSequence873); + } else { + throw new RuntimeException(("Illegal union index for 'F873': "+ unionIndex873)); + } + } + int unionIndex874 = (decoder.readIndex()); + if (unionIndex874 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(874, null); + } else { + if (unionIndex874 == 1) { + Utf8 charSequence874; + Object oldString874 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(874); + if (oldString874 instanceof Utf8) { + charSequence874 = (decoder).readString(((Utf8) oldString874)); + } else { + charSequence874 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(874, charSequence874); + } else { + throw new RuntimeException(("Illegal union index for 'F874': "+ unionIndex874)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex875 = (decoder.readIndex()); + if (unionIndex875 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(875, null); + } else { + if (unionIndex875 == 1) { + Utf8 charSequence875; + Object oldString875 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(875); + if (oldString875 instanceof Utf8) { + charSequence875 = (decoder).readString(((Utf8) oldString875)); + } else { + charSequence875 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(875, charSequence875); + } else { + throw new RuntimeException(("Illegal union index for 'F875': "+ unionIndex875)); + } + } + int unionIndex876 = (decoder.readIndex()); + if (unionIndex876 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(876, null); + } else { + if (unionIndex876 == 1) { + Utf8 charSequence876; + Object oldString876 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(876); + if (oldString876 instanceof Utf8) { + charSequence876 = (decoder).readString(((Utf8) oldString876)); + } else { + charSequence876 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(876, charSequence876); + } else { + throw new RuntimeException(("Illegal union index for 'F876': "+ unionIndex876)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex877 = (decoder.readIndex()); + if (unionIndex877 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(877, null); + } else { + if (unionIndex877 == 1) { + Utf8 charSequence877; + Object oldString877 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(877); + if (oldString877 instanceof Utf8) { + charSequence877 = (decoder).readString(((Utf8) oldString877)); + } else { + charSequence877 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(877, charSequence877); + } else { + throw new RuntimeException(("Illegal union index for 'F877': "+ unionIndex877)); + } + } + int unionIndex878 = (decoder.readIndex()); + if (unionIndex878 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(878, null); + } else { + if (unionIndex878 == 1) { + Utf8 charSequence878; + Object oldString878 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(878); + if (oldString878 instanceof Utf8) { + charSequence878 = (decoder).readString(((Utf8) oldString878)); + } else { + charSequence878 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(878, charSequence878); + } else { + throw new RuntimeException(("Illegal union index for 'F878': "+ unionIndex878)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex879 = (decoder.readIndex()); + if (unionIndex879 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(879, null); + } else { + if (unionIndex879 == 1) { + Utf8 charSequence879; + Object oldString879 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(879); + if (oldString879 instanceof Utf8) { + charSequence879 = (decoder).readString(((Utf8) oldString879)); + } else { + charSequence879 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(879, charSequence879); + } else { + throw new RuntimeException(("Illegal union index for 'F879': "+ unionIndex879)); + } + } + int unionIndex880 = (decoder.readIndex()); + if (unionIndex880 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(880, null); + } else { + if (unionIndex880 == 1) { + Utf8 charSequence880; + Object oldString880 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(880); + if (oldString880 instanceof Utf8) { + charSequence880 = (decoder).readString(((Utf8) oldString880)); + } else { + charSequence880 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(880, charSequence880); + } else { + throw new RuntimeException(("Illegal union index for 'F880': "+ unionIndex880)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex881 = (decoder.readIndex()); + if (unionIndex881 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(881, null); + } else { + if (unionIndex881 == 1) { + Utf8 charSequence881; + Object oldString881 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(881); + if (oldString881 instanceof Utf8) { + charSequence881 = (decoder).readString(((Utf8) oldString881)); + } else { + charSequence881 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(881, charSequence881); + } else { + throw new RuntimeException(("Illegal union index for 'F881': "+ unionIndex881)); + } + } + int unionIndex882 = (decoder.readIndex()); + if (unionIndex882 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(882, null); + } else { + if (unionIndex882 == 1) { + Utf8 charSequence882; + Object oldString882 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(882); + if (oldString882 instanceof Utf8) { + charSequence882 = (decoder).readString(((Utf8) oldString882)); + } else { + charSequence882 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(882, charSequence882); + } else { + throw new RuntimeException(("Illegal union index for 'F882': "+ unionIndex882)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex883 = (decoder.readIndex()); + if (unionIndex883 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(883, null); + } else { + if (unionIndex883 == 1) { + Utf8 charSequence883; + Object oldString883 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(883); + if (oldString883 instanceof Utf8) { + charSequence883 = (decoder).readString(((Utf8) oldString883)); + } else { + charSequence883 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(883, charSequence883); + } else { + throw new RuntimeException(("Illegal union index for 'F883': "+ unionIndex883)); + } + } + int unionIndex884 = (decoder.readIndex()); + if (unionIndex884 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(884, null); + } else { + if (unionIndex884 == 1) { + Utf8 charSequence884; + Object oldString884 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(884); + if (oldString884 instanceof Utf8) { + charSequence884 = (decoder).readString(((Utf8) oldString884)); + } else { + charSequence884 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(884, charSequence884); + } else { + throw new RuntimeException(("Illegal union index for 'F884': "+ unionIndex884)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex885 = (decoder.readIndex()); + if (unionIndex885 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(885, null); + } else { + if (unionIndex885 == 1) { + Utf8 charSequence885; + Object oldString885 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(885); + if (oldString885 instanceof Utf8) { + charSequence885 = (decoder).readString(((Utf8) oldString885)); + } else { + charSequence885 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(885, charSequence885); + } else { + throw new RuntimeException(("Illegal union index for 'F885': "+ unionIndex885)); + } + } + int unionIndex886 = (decoder.readIndex()); + if (unionIndex886 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(886, null); + } else { + if (unionIndex886 == 1) { + Utf8 charSequence886; + Object oldString886 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(886); + if (oldString886 instanceof Utf8) { + charSequence886 = (decoder).readString(((Utf8) oldString886)); + } else { + charSequence886 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(886, charSequence886); + } else { + throw new RuntimeException(("Illegal union index for 'F886': "+ unionIndex886)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex887 = (decoder.readIndex()); + if (unionIndex887 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(887, null); + } else { + if (unionIndex887 == 1) { + Utf8 charSequence887; + Object oldString887 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(887); + if (oldString887 instanceof Utf8) { + charSequence887 = (decoder).readString(((Utf8) oldString887)); + } else { + charSequence887 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(887, charSequence887); + } else { + throw new RuntimeException(("Illegal union index for 'F887': "+ unionIndex887)); + } + } + int unionIndex888 = (decoder.readIndex()); + if (unionIndex888 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(888, null); + } else { + if (unionIndex888 == 1) { + Utf8 charSequence888; + Object oldString888 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(888); + if (oldString888 instanceof Utf8) { + charSequence888 = (decoder).readString(((Utf8) oldString888)); + } else { + charSequence888 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(888, charSequence888); + } else { + throw new RuntimeException(("Illegal union index for 'F888': "+ unionIndex888)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex889 = (decoder.readIndex()); + if (unionIndex889 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(889, null); + } else { + if (unionIndex889 == 1) { + Utf8 charSequence889; + Object oldString889 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(889); + if (oldString889 instanceof Utf8) { + charSequence889 = (decoder).readString(((Utf8) oldString889)); + } else { + charSequence889 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(889, charSequence889); + } else { + throw new RuntimeException(("Illegal union index for 'F889': "+ unionIndex889)); + } + } + int unionIndex890 = (decoder.readIndex()); + if (unionIndex890 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(890, null); + } else { + if (unionIndex890 == 1) { + Utf8 charSequence890; + Object oldString890 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(890); + if (oldString890 instanceof Utf8) { + charSequence890 = (decoder).readString(((Utf8) oldString890)); + } else { + charSequence890 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(890, charSequence890); + } else { + throw new RuntimeException(("Illegal union index for 'F890': "+ unionIndex890)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex891 = (decoder.readIndex()); + if (unionIndex891 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(891, null); + } else { + if (unionIndex891 == 1) { + Utf8 charSequence891; + Object oldString891 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(891); + if (oldString891 instanceof Utf8) { + charSequence891 = (decoder).readString(((Utf8) oldString891)); + } else { + charSequence891 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(891, charSequence891); + } else { + throw new RuntimeException(("Illegal union index for 'F891': "+ unionIndex891)); + } + } + int unionIndex892 = (decoder.readIndex()); + if (unionIndex892 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(892, null); + } else { + if (unionIndex892 == 1) { + Utf8 charSequence892; + Object oldString892 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(892); + if (oldString892 instanceof Utf8) { + charSequence892 = (decoder).readString(((Utf8) oldString892)); + } else { + charSequence892 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(892, charSequence892); + } else { + throw new RuntimeException(("Illegal union index for 'F892': "+ unionIndex892)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex893 = (decoder.readIndex()); + if (unionIndex893 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(893, null); + } else { + if (unionIndex893 == 1) { + Utf8 charSequence893; + Object oldString893 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(893); + if (oldString893 instanceof Utf8) { + charSequence893 = (decoder).readString(((Utf8) oldString893)); + } else { + charSequence893 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(893, charSequence893); + } else { + throw new RuntimeException(("Illegal union index for 'F893': "+ unionIndex893)); + } + } + int unionIndex894 = (decoder.readIndex()); + if (unionIndex894 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(894, null); + } else { + if (unionIndex894 == 1) { + Utf8 charSequence894; + Object oldString894 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(894); + if (oldString894 instanceof Utf8) { + charSequence894 = (decoder).readString(((Utf8) oldString894)); + } else { + charSequence894 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(894, charSequence894); + } else { + throw new RuntimeException(("Illegal union index for 'F894': "+ unionIndex894)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex895 = (decoder.readIndex()); + if (unionIndex895 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(895, null); + } else { + if (unionIndex895 == 1) { + Utf8 charSequence895; + Object oldString895 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(895); + if (oldString895 instanceof Utf8) { + charSequence895 = (decoder).readString(((Utf8) oldString895)); + } else { + charSequence895 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(895, charSequence895); + } else { + throw new RuntimeException(("Illegal union index for 'F895': "+ unionIndex895)); + } + } + int unionIndex896 = (decoder.readIndex()); + if (unionIndex896 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(896, null); + } else { + if (unionIndex896 == 1) { + Utf8 charSequence896; + Object oldString896 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(896); + if (oldString896 instanceof Utf8) { + charSequence896 = (decoder).readString(((Utf8) oldString896)); + } else { + charSequence896 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(896, charSequence896); + } else { + throw new RuntimeException(("Illegal union index for 'F896': "+ unionIndex896)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex897 = (decoder.readIndex()); + if (unionIndex897 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(897, null); + } else { + if (unionIndex897 == 1) { + Utf8 charSequence897; + Object oldString897 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(897); + if (oldString897 instanceof Utf8) { + charSequence897 = (decoder).readString(((Utf8) oldString897)); + } else { + charSequence897 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(897, charSequence897); + } else { + throw new RuntimeException(("Illegal union index for 'F897': "+ unionIndex897)); + } + } + int unionIndex898 = (decoder.readIndex()); + if (unionIndex898 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(898, null); + } else { + if (unionIndex898 == 1) { + Utf8 charSequence898; + Object oldString898 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(898); + if (oldString898 instanceof Utf8) { + charSequence898 = (decoder).readString(((Utf8) oldString898)); + } else { + charSequence898 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(898, charSequence898); + } else { + throw new RuntimeException(("Illegal union index for 'F898': "+ unionIndex898)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex899 = (decoder.readIndex()); + if (unionIndex899 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(899, null); + } else { + if (unionIndex899 == 1) { + Utf8 charSequence899; + Object oldString899 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(899); + if (oldString899 instanceof Utf8) { + charSequence899 = (decoder).readString(((Utf8) oldString899)); + } else { + charSequence899 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(899, charSequence899); + } else { + throw new RuntimeException(("Illegal union index for 'F899': "+ unionIndex899)); + } + } + int unionIndex900 = (decoder.readIndex()); + if (unionIndex900 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(900, null); + } else { + if (unionIndex900 == 1) { + Utf8 charSequence900; + Object oldString900 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(900); + if (oldString900 instanceof Utf8) { + charSequence900 = (decoder).readString(((Utf8) oldString900)); + } else { + charSequence900 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(900, charSequence900); + } else { + throw new RuntimeException(("Illegal union index for 'F900': "+ unionIndex900)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex901 = (decoder.readIndex()); + if (unionIndex901 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(901, null); + } else { + if (unionIndex901 == 1) { + Utf8 charSequence901; + Object oldString901 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(901); + if (oldString901 instanceof Utf8) { + charSequence901 = (decoder).readString(((Utf8) oldString901)); + } else { + charSequence901 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(901, charSequence901); + } else { + throw new RuntimeException(("Illegal union index for 'F901': "+ unionIndex901)); + } + } + int unionIndex902 = (decoder.readIndex()); + if (unionIndex902 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(902, null); + } else { + if (unionIndex902 == 1) { + Utf8 charSequence902; + Object oldString902 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(902); + if (oldString902 instanceof Utf8) { + charSequence902 = (decoder).readString(((Utf8) oldString902)); + } else { + charSequence902 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(902, charSequence902); + } else { + throw new RuntimeException(("Illegal union index for 'F902': "+ unionIndex902)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex903 = (decoder.readIndex()); + if (unionIndex903 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(903, null); + } else { + if (unionIndex903 == 1) { + Utf8 charSequence903; + Object oldString903 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(903); + if (oldString903 instanceof Utf8) { + charSequence903 = (decoder).readString(((Utf8) oldString903)); + } else { + charSequence903 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(903, charSequence903); + } else { + throw new RuntimeException(("Illegal union index for 'F903': "+ unionIndex903)); + } + } + int unionIndex904 = (decoder.readIndex()); + if (unionIndex904 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(904, null); + } else { + if (unionIndex904 == 1) { + Utf8 charSequence904; + Object oldString904 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(904); + if (oldString904 instanceof Utf8) { + charSequence904 = (decoder).readString(((Utf8) oldString904)); + } else { + charSequence904 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(904, charSequence904); + } else { + throw new RuntimeException(("Illegal union index for 'F904': "+ unionIndex904)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex905 = (decoder.readIndex()); + if (unionIndex905 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(905, null); + } else { + if (unionIndex905 == 1) { + Utf8 charSequence905; + Object oldString905 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(905); + if (oldString905 instanceof Utf8) { + charSequence905 = (decoder).readString(((Utf8) oldString905)); + } else { + charSequence905 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(905, charSequence905); + } else { + throw new RuntimeException(("Illegal union index for 'F905': "+ unionIndex905)); + } + } + int unionIndex906 = (decoder.readIndex()); + if (unionIndex906 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(906, null); + } else { + if (unionIndex906 == 1) { + Utf8 charSequence906; + Object oldString906 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(906); + if (oldString906 instanceof Utf8) { + charSequence906 = (decoder).readString(((Utf8) oldString906)); + } else { + charSequence906 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(906, charSequence906); + } else { + throw new RuntimeException(("Illegal union index for 'F906': "+ unionIndex906)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex907 = (decoder.readIndex()); + if (unionIndex907 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(907, null); + } else { + if (unionIndex907 == 1) { + Utf8 charSequence907; + Object oldString907 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(907); + if (oldString907 instanceof Utf8) { + charSequence907 = (decoder).readString(((Utf8) oldString907)); + } else { + charSequence907 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(907, charSequence907); + } else { + throw new RuntimeException(("Illegal union index for 'F907': "+ unionIndex907)); + } + } + int unionIndex908 = (decoder.readIndex()); + if (unionIndex908 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(908, null); + } else { + if (unionIndex908 == 1) { + Utf8 charSequence908; + Object oldString908 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(908); + if (oldString908 instanceof Utf8) { + charSequence908 = (decoder).readString(((Utf8) oldString908)); + } else { + charSequence908 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(908, charSequence908); + } else { + throw new RuntimeException(("Illegal union index for 'F908': "+ unionIndex908)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex909 = (decoder.readIndex()); + if (unionIndex909 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(909, null); + } else { + if (unionIndex909 == 1) { + Utf8 charSequence909; + Object oldString909 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(909); + if (oldString909 instanceof Utf8) { + charSequence909 = (decoder).readString(((Utf8) oldString909)); + } else { + charSequence909 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(909, charSequence909); + } else { + throw new RuntimeException(("Illegal union index for 'F909': "+ unionIndex909)); + } + } + int unionIndex910 = (decoder.readIndex()); + if (unionIndex910 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(910, null); + } else { + if (unionIndex910 == 1) { + Utf8 charSequence910; + Object oldString910 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(910); + if (oldString910 instanceof Utf8) { + charSequence910 = (decoder).readString(((Utf8) oldString910)); + } else { + charSequence910 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(910, charSequence910); + } else { + throw new RuntimeException(("Illegal union index for 'F910': "+ unionIndex910)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex911 = (decoder.readIndex()); + if (unionIndex911 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(911, null); + } else { + if (unionIndex911 == 1) { + Utf8 charSequence911; + Object oldString911 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(911); + if (oldString911 instanceof Utf8) { + charSequence911 = (decoder).readString(((Utf8) oldString911)); + } else { + charSequence911 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(911, charSequence911); + } else { + throw new RuntimeException(("Illegal union index for 'F911': "+ unionIndex911)); + } + } + int unionIndex912 = (decoder.readIndex()); + if (unionIndex912 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(912, null); + } else { + if (unionIndex912 == 1) { + Utf8 charSequence912; + Object oldString912 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(912); + if (oldString912 instanceof Utf8) { + charSequence912 = (decoder).readString(((Utf8) oldString912)); + } else { + charSequence912 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(912, charSequence912); + } else { + throw new RuntimeException(("Illegal union index for 'F912': "+ unionIndex912)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex913 = (decoder.readIndex()); + if (unionIndex913 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(913, null); + } else { + if (unionIndex913 == 1) { + Utf8 charSequence913; + Object oldString913 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(913); + if (oldString913 instanceof Utf8) { + charSequence913 = (decoder).readString(((Utf8) oldString913)); + } else { + charSequence913 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(913, charSequence913); + } else { + throw new RuntimeException(("Illegal union index for 'F913': "+ unionIndex913)); + } + } + int unionIndex914 = (decoder.readIndex()); + if (unionIndex914 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(914, null); + } else { + if (unionIndex914 == 1) { + Utf8 charSequence914; + Object oldString914 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(914); + if (oldString914 instanceof Utf8) { + charSequence914 = (decoder).readString(((Utf8) oldString914)); + } else { + charSequence914 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(914, charSequence914); + } else { + throw new RuntimeException(("Illegal union index for 'F914': "+ unionIndex914)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex915 = (decoder.readIndex()); + if (unionIndex915 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(915, null); + } else { + if (unionIndex915 == 1) { + Utf8 charSequence915; + Object oldString915 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(915); + if (oldString915 instanceof Utf8) { + charSequence915 = (decoder).readString(((Utf8) oldString915)); + } else { + charSequence915 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(915, charSequence915); + } else { + throw new RuntimeException(("Illegal union index for 'F915': "+ unionIndex915)); + } + } + int unionIndex916 = (decoder.readIndex()); + if (unionIndex916 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(916, null); + } else { + if (unionIndex916 == 1) { + Utf8 charSequence916; + Object oldString916 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(916); + if (oldString916 instanceof Utf8) { + charSequence916 = (decoder).readString(((Utf8) oldString916)); + } else { + charSequence916 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(916, charSequence916); + } else { + throw new RuntimeException(("Illegal union index for 'F916': "+ unionIndex916)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex917 = (decoder.readIndex()); + if (unionIndex917 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(917, null); + } else { + if (unionIndex917 == 1) { + Utf8 charSequence917; + Object oldString917 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(917); + if (oldString917 instanceof Utf8) { + charSequence917 = (decoder).readString(((Utf8) oldString917)); + } else { + charSequence917 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(917, charSequence917); + } else { + throw new RuntimeException(("Illegal union index for 'F917': "+ unionIndex917)); + } + } + int unionIndex918 = (decoder.readIndex()); + if (unionIndex918 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(918, null); + } else { + if (unionIndex918 == 1) { + Utf8 charSequence918; + Object oldString918 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(918); + if (oldString918 instanceof Utf8) { + charSequence918 = (decoder).readString(((Utf8) oldString918)); + } else { + charSequence918 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(918, charSequence918); + } else { + throw new RuntimeException(("Illegal union index for 'F918': "+ unionIndex918)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex919 = (decoder.readIndex()); + if (unionIndex919 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(919, null); + } else { + if (unionIndex919 == 1) { + Utf8 charSequence919; + Object oldString919 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(919); + if (oldString919 instanceof Utf8) { + charSequence919 = (decoder).readString(((Utf8) oldString919)); + } else { + charSequence919 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(919, charSequence919); + } else { + throw new RuntimeException(("Illegal union index for 'F919': "+ unionIndex919)); + } + } + int unionIndex920 = (decoder.readIndex()); + if (unionIndex920 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(920, null); + } else { + if (unionIndex920 == 1) { + Utf8 charSequence920; + Object oldString920 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(920); + if (oldString920 instanceof Utf8) { + charSequence920 = (decoder).readString(((Utf8) oldString920)); + } else { + charSequence920 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(920, charSequence920); + } else { + throw new RuntimeException(("Illegal union index for 'F920': "+ unionIndex920)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex921 = (decoder.readIndex()); + if (unionIndex921 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(921, null); + } else { + if (unionIndex921 == 1) { + Utf8 charSequence921; + Object oldString921 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(921); + if (oldString921 instanceof Utf8) { + charSequence921 = (decoder).readString(((Utf8) oldString921)); + } else { + charSequence921 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(921, charSequence921); + } else { + throw new RuntimeException(("Illegal union index for 'F921': "+ unionIndex921)); + } + } + int unionIndex922 = (decoder.readIndex()); + if (unionIndex922 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(922, null); + } else { + if (unionIndex922 == 1) { + Utf8 charSequence922; + Object oldString922 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(922); + if (oldString922 instanceof Utf8) { + charSequence922 = (decoder).readString(((Utf8) oldString922)); + } else { + charSequence922 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(922, charSequence922); + } else { + throw new RuntimeException(("Illegal union index for 'F922': "+ unionIndex922)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex923 = (decoder.readIndex()); + if (unionIndex923 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(923, null); + } else { + if (unionIndex923 == 1) { + Utf8 charSequence923; + Object oldString923 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(923); + if (oldString923 instanceof Utf8) { + charSequence923 = (decoder).readString(((Utf8) oldString923)); + } else { + charSequence923 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(923, charSequence923); + } else { + throw new RuntimeException(("Illegal union index for 'F923': "+ unionIndex923)); + } + } + int unionIndex924 = (decoder.readIndex()); + if (unionIndex924 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(924, null); + } else { + if (unionIndex924 == 1) { + Utf8 charSequence924; + Object oldString924 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(924); + if (oldString924 instanceof Utf8) { + charSequence924 = (decoder).readString(((Utf8) oldString924)); + } else { + charSequence924 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(924, charSequence924); + } else { + throw new RuntimeException(("Illegal union index for 'F924': "+ unionIndex924)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex925 = (decoder.readIndex()); + if (unionIndex925 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(925, null); + } else { + if (unionIndex925 == 1) { + Utf8 charSequence925; + Object oldString925 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(925); + if (oldString925 instanceof Utf8) { + charSequence925 = (decoder).readString(((Utf8) oldString925)); + } else { + charSequence925 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(925, charSequence925); + } else { + throw new RuntimeException(("Illegal union index for 'F925': "+ unionIndex925)); + } + } + int unionIndex926 = (decoder.readIndex()); + if (unionIndex926 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(926, null); + } else { + if (unionIndex926 == 1) { + Utf8 charSequence926; + Object oldString926 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(926); + if (oldString926 instanceof Utf8) { + charSequence926 = (decoder).readString(((Utf8) oldString926)); + } else { + charSequence926 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(926, charSequence926); + } else { + throw new RuntimeException(("Illegal union index for 'F926': "+ unionIndex926)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex927 = (decoder.readIndex()); + if (unionIndex927 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(927, null); + } else { + if (unionIndex927 == 1) { + Utf8 charSequence927; + Object oldString927 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(927); + if (oldString927 instanceof Utf8) { + charSequence927 = (decoder).readString(((Utf8) oldString927)); + } else { + charSequence927 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(927, charSequence927); + } else { + throw new RuntimeException(("Illegal union index for 'F927': "+ unionIndex927)); + } + } + int unionIndex928 = (decoder.readIndex()); + if (unionIndex928 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(928, null); + } else { + if (unionIndex928 == 1) { + Utf8 charSequence928; + Object oldString928 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(928); + if (oldString928 instanceof Utf8) { + charSequence928 = (decoder).readString(((Utf8) oldString928)); + } else { + charSequence928 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(928, charSequence928); + } else { + throw new RuntimeException(("Illegal union index for 'F928': "+ unionIndex928)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex929 = (decoder.readIndex()); + if (unionIndex929 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(929, null); + } else { + if (unionIndex929 == 1) { + Utf8 charSequence929; + Object oldString929 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(929); + if (oldString929 instanceof Utf8) { + charSequence929 = (decoder).readString(((Utf8) oldString929)); + } else { + charSequence929 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(929, charSequence929); + } else { + throw new RuntimeException(("Illegal union index for 'F929': "+ unionIndex929)); + } + } + int unionIndex930 = (decoder.readIndex()); + if (unionIndex930 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(930, null); + } else { + if (unionIndex930 == 1) { + Utf8 charSequence930; + Object oldString930 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(930); + if (oldString930 instanceof Utf8) { + charSequence930 = (decoder).readString(((Utf8) oldString930)); + } else { + charSequence930 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(930, charSequence930); + } else { + throw new RuntimeException(("Illegal union index for 'F930': "+ unionIndex930)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex931 = (decoder.readIndex()); + if (unionIndex931 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(931, null); + } else { + if (unionIndex931 == 1) { + Utf8 charSequence931; + Object oldString931 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(931); + if (oldString931 instanceof Utf8) { + charSequence931 = (decoder).readString(((Utf8) oldString931)); + } else { + charSequence931 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(931, charSequence931); + } else { + throw new RuntimeException(("Illegal union index for 'F931': "+ unionIndex931)); + } + } + int unionIndex932 = (decoder.readIndex()); + if (unionIndex932 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(932, null); + } else { + if (unionIndex932 == 1) { + Utf8 charSequence932; + Object oldString932 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(932); + if (oldString932 instanceof Utf8) { + charSequence932 = (decoder).readString(((Utf8) oldString932)); + } else { + charSequence932 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(932, charSequence932); + } else { + throw new RuntimeException(("Illegal union index for 'F932': "+ unionIndex932)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex933 = (decoder.readIndex()); + if (unionIndex933 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(933, null); + } else { + if (unionIndex933 == 1) { + Utf8 charSequence933; + Object oldString933 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(933); + if (oldString933 instanceof Utf8) { + charSequence933 = (decoder).readString(((Utf8) oldString933)); + } else { + charSequence933 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(933, charSequence933); + } else { + throw new RuntimeException(("Illegal union index for 'F933': "+ unionIndex933)); + } + } + int unionIndex934 = (decoder.readIndex()); + if (unionIndex934 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(934, null); + } else { + if (unionIndex934 == 1) { + Utf8 charSequence934; + Object oldString934 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(934); + if (oldString934 instanceof Utf8) { + charSequence934 = (decoder).readString(((Utf8) oldString934)); + } else { + charSequence934 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(934, charSequence934); + } else { + throw new RuntimeException(("Illegal union index for 'F934': "+ unionIndex934)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex935 = (decoder.readIndex()); + if (unionIndex935 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(935, null); + } else { + if (unionIndex935 == 1) { + Utf8 charSequence935; + Object oldString935 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(935); + if (oldString935 instanceof Utf8) { + charSequence935 = (decoder).readString(((Utf8) oldString935)); + } else { + charSequence935 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(935, charSequence935); + } else { + throw new RuntimeException(("Illegal union index for 'F935': "+ unionIndex935)); + } + } + int unionIndex936 = (decoder.readIndex()); + if (unionIndex936 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(936, null); + } else { + if (unionIndex936 == 1) { + Utf8 charSequence936; + Object oldString936 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(936); + if (oldString936 instanceof Utf8) { + charSequence936 = (decoder).readString(((Utf8) oldString936)); + } else { + charSequence936 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(936, charSequence936); + } else { + throw new RuntimeException(("Illegal union index for 'F936': "+ unionIndex936)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex937 = (decoder.readIndex()); + if (unionIndex937 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(937, null); + } else { + if (unionIndex937 == 1) { + Utf8 charSequence937; + Object oldString937 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(937); + if (oldString937 instanceof Utf8) { + charSequence937 = (decoder).readString(((Utf8) oldString937)); + } else { + charSequence937 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(937, charSequence937); + } else { + throw new RuntimeException(("Illegal union index for 'F937': "+ unionIndex937)); + } + } + int unionIndex938 = (decoder.readIndex()); + if (unionIndex938 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(938, null); + } else { + if (unionIndex938 == 1) { + Utf8 charSequence938; + Object oldString938 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(938); + if (oldString938 instanceof Utf8) { + charSequence938 = (decoder).readString(((Utf8) oldString938)); + } else { + charSequence938 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(938, charSequence938); + } else { + throw new RuntimeException(("Illegal union index for 'F938': "+ unionIndex938)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex939 = (decoder.readIndex()); + if (unionIndex939 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(939, null); + } else { + if (unionIndex939 == 1) { + Utf8 charSequence939; + Object oldString939 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(939); + if (oldString939 instanceof Utf8) { + charSequence939 = (decoder).readString(((Utf8) oldString939)); + } else { + charSequence939 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(939, charSequence939); + } else { + throw new RuntimeException(("Illegal union index for 'F939': "+ unionIndex939)); + } + } + int unionIndex940 = (decoder.readIndex()); + if (unionIndex940 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(940, null); + } else { + if (unionIndex940 == 1) { + Utf8 charSequence940; + Object oldString940 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(940); + if (oldString940 instanceof Utf8) { + charSequence940 = (decoder).readString(((Utf8) oldString940)); + } else { + charSequence940 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(940, charSequence940); + } else { + throw new RuntimeException(("Illegal union index for 'F940': "+ unionIndex940)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex941 = (decoder.readIndex()); + if (unionIndex941 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(941, null); + } else { + if (unionIndex941 == 1) { + Utf8 charSequence941; + Object oldString941 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(941); + if (oldString941 instanceof Utf8) { + charSequence941 = (decoder).readString(((Utf8) oldString941)); + } else { + charSequence941 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(941, charSequence941); + } else { + throw new RuntimeException(("Illegal union index for 'F941': "+ unionIndex941)); + } + } + int unionIndex942 = (decoder.readIndex()); + if (unionIndex942 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(942, null); + } else { + if (unionIndex942 == 1) { + Utf8 charSequence942; + Object oldString942 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(942); + if (oldString942 instanceof Utf8) { + charSequence942 = (decoder).readString(((Utf8) oldString942)); + } else { + charSequence942 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(942, charSequence942); + } else { + throw new RuntimeException(("Illegal union index for 'F942': "+ unionIndex942)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex943 = (decoder.readIndex()); + if (unionIndex943 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(943, null); + } else { + if (unionIndex943 == 1) { + Utf8 charSequence943; + Object oldString943 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(943); + if (oldString943 instanceof Utf8) { + charSequence943 = (decoder).readString(((Utf8) oldString943)); + } else { + charSequence943 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(943, charSequence943); + } else { + throw new RuntimeException(("Illegal union index for 'F943': "+ unionIndex943)); + } + } + int unionIndex944 = (decoder.readIndex()); + if (unionIndex944 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(944, null); + } else { + if (unionIndex944 == 1) { + Utf8 charSequence944; + Object oldString944 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(944); + if (oldString944 instanceof Utf8) { + charSequence944 = (decoder).readString(((Utf8) oldString944)); + } else { + charSequence944 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(944, charSequence944); + } else { + throw new RuntimeException(("Illegal union index for 'F944': "+ unionIndex944)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex945 = (decoder.readIndex()); + if (unionIndex945 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(945, null); + } else { + if (unionIndex945 == 1) { + Utf8 charSequence945; + Object oldString945 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(945); + if (oldString945 instanceof Utf8) { + charSequence945 = (decoder).readString(((Utf8) oldString945)); + } else { + charSequence945 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(945, charSequence945); + } else { + throw new RuntimeException(("Illegal union index for 'F945': "+ unionIndex945)); + } + } + int unionIndex946 = (decoder.readIndex()); + if (unionIndex946 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(946, null); + } else { + if (unionIndex946 == 1) { + Utf8 charSequence946; + Object oldString946 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(946); + if (oldString946 instanceof Utf8) { + charSequence946 = (decoder).readString(((Utf8) oldString946)); + } else { + charSequence946 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(946, charSequence946); + } else { + throw new RuntimeException(("Illegal union index for 'F946': "+ unionIndex946)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex947 = (decoder.readIndex()); + if (unionIndex947 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(947, null); + } else { + if (unionIndex947 == 1) { + Utf8 charSequence947; + Object oldString947 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(947); + if (oldString947 instanceof Utf8) { + charSequence947 = (decoder).readString(((Utf8) oldString947)); + } else { + charSequence947 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(947, charSequence947); + } else { + throw new RuntimeException(("Illegal union index for 'F947': "+ unionIndex947)); + } + } + int unionIndex948 = (decoder.readIndex()); + if (unionIndex948 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(948, null); + } else { + if (unionIndex948 == 1) { + Utf8 charSequence948; + Object oldString948 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(948); + if (oldString948 instanceof Utf8) { + charSequence948 = (decoder).readString(((Utf8) oldString948)); + } else { + charSequence948 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(948, charSequence948); + } else { + throw new RuntimeException(("Illegal union index for 'F948': "+ unionIndex948)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex949 = (decoder.readIndex()); + if (unionIndex949 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(949, null); + } else { + if (unionIndex949 == 1) { + Utf8 charSequence949; + Object oldString949 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(949); + if (oldString949 instanceof Utf8) { + charSequence949 = (decoder).readString(((Utf8) oldString949)); + } else { + charSequence949 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(949, charSequence949); + } else { + throw new RuntimeException(("Illegal union index for 'F949': "+ unionIndex949)); + } + } + int unionIndex950 = (decoder.readIndex()); + if (unionIndex950 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(950, null); + } else { + if (unionIndex950 == 1) { + Utf8 charSequence950; + Object oldString950 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(950); + if (oldString950 instanceof Utf8) { + charSequence950 = (decoder).readString(((Utf8) oldString950)); + } else { + charSequence950 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(950, charSequence950); + } else { + throw new RuntimeException(("Illegal union index for 'F950': "+ unionIndex950)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex951 = (decoder.readIndex()); + if (unionIndex951 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(951, null); + } else { + if (unionIndex951 == 1) { + Utf8 charSequence951; + Object oldString951 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(951); + if (oldString951 instanceof Utf8) { + charSequence951 = (decoder).readString(((Utf8) oldString951)); + } else { + charSequence951 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(951, charSequence951); + } else { + throw new RuntimeException(("Illegal union index for 'F951': "+ unionIndex951)); + } + } + int unionIndex952 = (decoder.readIndex()); + if (unionIndex952 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(952, null); + } else { + if (unionIndex952 == 1) { + Utf8 charSequence952; + Object oldString952 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(952); + if (oldString952 instanceof Utf8) { + charSequence952 = (decoder).readString(((Utf8) oldString952)); + } else { + charSequence952 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(952, charSequence952); + } else { + throw new RuntimeException(("Illegal union index for 'F952': "+ unionIndex952)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex953 = (decoder.readIndex()); + if (unionIndex953 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(953, null); + } else { + if (unionIndex953 == 1) { + Utf8 charSequence953; + Object oldString953 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(953); + if (oldString953 instanceof Utf8) { + charSequence953 = (decoder).readString(((Utf8) oldString953)); + } else { + charSequence953 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(953, charSequence953); + } else { + throw new RuntimeException(("Illegal union index for 'F953': "+ unionIndex953)); + } + } + int unionIndex954 = (decoder.readIndex()); + if (unionIndex954 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(954, null); + } else { + if (unionIndex954 == 1) { + Utf8 charSequence954; + Object oldString954 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(954); + if (oldString954 instanceof Utf8) { + charSequence954 = (decoder).readString(((Utf8) oldString954)); + } else { + charSequence954 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(954, charSequence954); + } else { + throw new RuntimeException(("Illegal union index for 'F954': "+ unionIndex954)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex955 = (decoder.readIndex()); + if (unionIndex955 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(955, null); + } else { + if (unionIndex955 == 1) { + Utf8 charSequence955; + Object oldString955 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(955); + if (oldString955 instanceof Utf8) { + charSequence955 = (decoder).readString(((Utf8) oldString955)); + } else { + charSequence955 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(955, charSequence955); + } else { + throw new RuntimeException(("Illegal union index for 'F955': "+ unionIndex955)); + } + } + int unionIndex956 = (decoder.readIndex()); + if (unionIndex956 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(956, null); + } else { + if (unionIndex956 == 1) { + Utf8 charSequence956; + Object oldString956 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(956); + if (oldString956 instanceof Utf8) { + charSequence956 = (decoder).readString(((Utf8) oldString956)); + } else { + charSequence956 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(956, charSequence956); + } else { + throw new RuntimeException(("Illegal union index for 'F956': "+ unionIndex956)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex957 = (decoder.readIndex()); + if (unionIndex957 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(957, null); + } else { + if (unionIndex957 == 1) { + Utf8 charSequence957; + Object oldString957 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(957); + if (oldString957 instanceof Utf8) { + charSequence957 = (decoder).readString(((Utf8) oldString957)); + } else { + charSequence957 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(957, charSequence957); + } else { + throw new RuntimeException(("Illegal union index for 'F957': "+ unionIndex957)); + } + } + int unionIndex958 = (decoder.readIndex()); + if (unionIndex958 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(958, null); + } else { + if (unionIndex958 == 1) { + Utf8 charSequence958; + Object oldString958 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(958); + if (oldString958 instanceof Utf8) { + charSequence958 = (decoder).readString(((Utf8) oldString958)); + } else { + charSequence958 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(958, charSequence958); + } else { + throw new RuntimeException(("Illegal union index for 'F958': "+ unionIndex958)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex959 = (decoder.readIndex()); + if (unionIndex959 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(959, null); + } else { + if (unionIndex959 == 1) { + Utf8 charSequence959; + Object oldString959 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(959); + if (oldString959 instanceof Utf8) { + charSequence959 = (decoder).readString(((Utf8) oldString959)); + } else { + charSequence959 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(959, charSequence959); + } else { + throw new RuntimeException(("Illegal union index for 'F959': "+ unionIndex959)); + } + } + int unionIndex960 = (decoder.readIndex()); + if (unionIndex960 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(960, null); + } else { + if (unionIndex960 == 1) { + Utf8 charSequence960; + Object oldString960 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(960); + if (oldString960 instanceof Utf8) { + charSequence960 = (decoder).readString(((Utf8) oldString960)); + } else { + charSequence960 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(960, charSequence960); + } else { + throw new RuntimeException(("Illegal union index for 'F960': "+ unionIndex960)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex961 = (decoder.readIndex()); + if (unionIndex961 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(961, null); + } else { + if (unionIndex961 == 1) { + Utf8 charSequence961; + Object oldString961 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(961); + if (oldString961 instanceof Utf8) { + charSequence961 = (decoder).readString(((Utf8) oldString961)); + } else { + charSequence961 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(961, charSequence961); + } else { + throw new RuntimeException(("Illegal union index for 'F961': "+ unionIndex961)); + } + } + int unionIndex962 = (decoder.readIndex()); + if (unionIndex962 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(962, null); + } else { + if (unionIndex962 == 1) { + Utf8 charSequence962; + Object oldString962 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(962); + if (oldString962 instanceof Utf8) { + charSequence962 = (decoder).readString(((Utf8) oldString962)); + } else { + charSequence962 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(962, charSequence962); + } else { + throw new RuntimeException(("Illegal union index for 'F962': "+ unionIndex962)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex963 = (decoder.readIndex()); + if (unionIndex963 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(963, null); + } else { + if (unionIndex963 == 1) { + Utf8 charSequence963; + Object oldString963 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(963); + if (oldString963 instanceof Utf8) { + charSequence963 = (decoder).readString(((Utf8) oldString963)); + } else { + charSequence963 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(963, charSequence963); + } else { + throw new RuntimeException(("Illegal union index for 'F963': "+ unionIndex963)); + } + } + int unionIndex964 = (decoder.readIndex()); + if (unionIndex964 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(964, null); + } else { + if (unionIndex964 == 1) { + Utf8 charSequence964; + Object oldString964 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(964); + if (oldString964 instanceof Utf8) { + charSequence964 = (decoder).readString(((Utf8) oldString964)); + } else { + charSequence964 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(964, charSequence964); + } else { + throw new RuntimeException(("Illegal union index for 'F964': "+ unionIndex964)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex965 = (decoder.readIndex()); + if (unionIndex965 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(965, null); + } else { + if (unionIndex965 == 1) { + Utf8 charSequence965; + Object oldString965 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(965); + if (oldString965 instanceof Utf8) { + charSequence965 = (decoder).readString(((Utf8) oldString965)); + } else { + charSequence965 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(965, charSequence965); + } else { + throw new RuntimeException(("Illegal union index for 'F965': "+ unionIndex965)); + } + } + int unionIndex966 = (decoder.readIndex()); + if (unionIndex966 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(966, null); + } else { + if (unionIndex966 == 1) { + Utf8 charSequence966; + Object oldString966 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(966); + if (oldString966 instanceof Utf8) { + charSequence966 = (decoder).readString(((Utf8) oldString966)); + } else { + charSequence966 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(966, charSequence966); + } else { + throw new RuntimeException(("Illegal union index for 'F966': "+ unionIndex966)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex967 = (decoder.readIndex()); + if (unionIndex967 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(967, null); + } else { + if (unionIndex967 == 1) { + Utf8 charSequence967; + Object oldString967 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(967); + if (oldString967 instanceof Utf8) { + charSequence967 = (decoder).readString(((Utf8) oldString967)); + } else { + charSequence967 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(967, charSequence967); + } else { + throw new RuntimeException(("Illegal union index for 'F967': "+ unionIndex967)); + } + } + int unionIndex968 = (decoder.readIndex()); + if (unionIndex968 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(968, null); + } else { + if (unionIndex968 == 1) { + Utf8 charSequence968; + Object oldString968 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(968); + if (oldString968 instanceof Utf8) { + charSequence968 = (decoder).readString(((Utf8) oldString968)); + } else { + charSequence968 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(968, charSequence968); + } else { + throw new RuntimeException(("Illegal union index for 'F968': "+ unionIndex968)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex969 = (decoder.readIndex()); + if (unionIndex969 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(969, null); + } else { + if (unionIndex969 == 1) { + Utf8 charSequence969; + Object oldString969 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(969); + if (oldString969 instanceof Utf8) { + charSequence969 = (decoder).readString(((Utf8) oldString969)); + } else { + charSequence969 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(969, charSequence969); + } else { + throw new RuntimeException(("Illegal union index for 'F969': "+ unionIndex969)); + } + } + int unionIndex970 = (decoder.readIndex()); + if (unionIndex970 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(970, null); + } else { + if (unionIndex970 == 1) { + Utf8 charSequence970; + Object oldString970 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(970); + if (oldString970 instanceof Utf8) { + charSequence970 = (decoder).readString(((Utf8) oldString970)); + } else { + charSequence970 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(970, charSequence970); + } else { + throw new RuntimeException(("Illegal union index for 'F970': "+ unionIndex970)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex971 = (decoder.readIndex()); + if (unionIndex971 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(971, null); + } else { + if (unionIndex971 == 1) { + Utf8 charSequence971; + Object oldString971 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(971); + if (oldString971 instanceof Utf8) { + charSequence971 = (decoder).readString(((Utf8) oldString971)); + } else { + charSequence971 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(971, charSequence971); + } else { + throw new RuntimeException(("Illegal union index for 'F971': "+ unionIndex971)); + } + } + int unionIndex972 = (decoder.readIndex()); + if (unionIndex972 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(972, null); + } else { + if (unionIndex972 == 1) { + Utf8 charSequence972; + Object oldString972 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(972); + if (oldString972 instanceof Utf8) { + charSequence972 = (decoder).readString(((Utf8) oldString972)); + } else { + charSequence972 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(972, charSequence972); + } else { + throw new RuntimeException(("Illegal union index for 'F972': "+ unionIndex972)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex973 = (decoder.readIndex()); + if (unionIndex973 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(973, null); + } else { + if (unionIndex973 == 1) { + Utf8 charSequence973; + Object oldString973 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(973); + if (oldString973 instanceof Utf8) { + charSequence973 = (decoder).readString(((Utf8) oldString973)); + } else { + charSequence973 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(973, charSequence973); + } else { + throw new RuntimeException(("Illegal union index for 'F973': "+ unionIndex973)); + } + } + int unionIndex974 = (decoder.readIndex()); + if (unionIndex974 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(974, null); + } else { + if (unionIndex974 == 1) { + Utf8 charSequence974; + Object oldString974 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(974); + if (oldString974 instanceof Utf8) { + charSequence974 = (decoder).readString(((Utf8) oldString974)); + } else { + charSequence974 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(974, charSequence974); + } else { + throw new RuntimeException(("Illegal union index for 'F974': "+ unionIndex974)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex975 = (decoder.readIndex()); + if (unionIndex975 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(975, null); + } else { + if (unionIndex975 == 1) { + Utf8 charSequence975; + Object oldString975 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(975); + if (oldString975 instanceof Utf8) { + charSequence975 = (decoder).readString(((Utf8) oldString975)); + } else { + charSequence975 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(975, charSequence975); + } else { + throw new RuntimeException(("Illegal union index for 'F975': "+ unionIndex975)); + } + } + int unionIndex976 = (decoder.readIndex()); + if (unionIndex976 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(976, null); + } else { + if (unionIndex976 == 1) { + Utf8 charSequence976; + Object oldString976 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(976); + if (oldString976 instanceof Utf8) { + charSequence976 = (decoder).readString(((Utf8) oldString976)); + } else { + charSequence976 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(976, charSequence976); + } else { + throw new RuntimeException(("Illegal union index for 'F976': "+ unionIndex976)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex977 = (decoder.readIndex()); + if (unionIndex977 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(977, null); + } else { + if (unionIndex977 == 1) { + Utf8 charSequence977; + Object oldString977 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(977); + if (oldString977 instanceof Utf8) { + charSequence977 = (decoder).readString(((Utf8) oldString977)); + } else { + charSequence977 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(977, charSequence977); + } else { + throw new RuntimeException(("Illegal union index for 'F977': "+ unionIndex977)); + } + } + int unionIndex978 = (decoder.readIndex()); + if (unionIndex978 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(978, null); + } else { + if (unionIndex978 == 1) { + Utf8 charSequence978; + Object oldString978 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(978); + if (oldString978 instanceof Utf8) { + charSequence978 = (decoder).readString(((Utf8) oldString978)); + } else { + charSequence978 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(978, charSequence978); + } else { + throw new RuntimeException(("Illegal union index for 'F978': "+ unionIndex978)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex979 = (decoder.readIndex()); + if (unionIndex979 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(979, null); + } else { + if (unionIndex979 == 1) { + Utf8 charSequence979; + Object oldString979 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(979); + if (oldString979 instanceof Utf8) { + charSequence979 = (decoder).readString(((Utf8) oldString979)); + } else { + charSequence979 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(979, charSequence979); + } else { + throw new RuntimeException(("Illegal union index for 'F979': "+ unionIndex979)); + } + } + int unionIndex980 = (decoder.readIndex()); + if (unionIndex980 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(980, null); + } else { + if (unionIndex980 == 1) { + Utf8 charSequence980; + Object oldString980 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(980); + if (oldString980 instanceof Utf8) { + charSequence980 = (decoder).readString(((Utf8) oldString980)); + } else { + charSequence980 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(980, charSequence980); + } else { + throw new RuntimeException(("Illegal union index for 'F980': "+ unionIndex980)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex981 = (decoder.readIndex()); + if (unionIndex981 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(981, null); + } else { + if (unionIndex981 == 1) { + Utf8 charSequence981; + Object oldString981 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(981); + if (oldString981 instanceof Utf8) { + charSequence981 = (decoder).readString(((Utf8) oldString981)); + } else { + charSequence981 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(981, charSequence981); + } else { + throw new RuntimeException(("Illegal union index for 'F981': "+ unionIndex981)); + } + } + int unionIndex982 = (decoder.readIndex()); + if (unionIndex982 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(982, null); + } else { + if (unionIndex982 == 1) { + Utf8 charSequence982; + Object oldString982 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(982); + if (oldString982 instanceof Utf8) { + charSequence982 = (decoder).readString(((Utf8) oldString982)); + } else { + charSequence982 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(982, charSequence982); + } else { + throw new RuntimeException(("Illegal union index for 'F982': "+ unionIndex982)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex983 = (decoder.readIndex()); + if (unionIndex983 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(983, null); + } else { + if (unionIndex983 == 1) { + Utf8 charSequence983; + Object oldString983 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(983); + if (oldString983 instanceof Utf8) { + charSequence983 = (decoder).readString(((Utf8) oldString983)); + } else { + charSequence983 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(983, charSequence983); + } else { + throw new RuntimeException(("Illegal union index for 'F983': "+ unionIndex983)); + } + } + int unionIndex984 = (decoder.readIndex()); + if (unionIndex984 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(984, null); + } else { + if (unionIndex984 == 1) { + Utf8 charSequence984; + Object oldString984 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(984); + if (oldString984 instanceof Utf8) { + charSequence984 = (decoder).readString(((Utf8) oldString984)); + } else { + charSequence984 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(984, charSequence984); + } else { + throw new RuntimeException(("Illegal union index for 'F984': "+ unionIndex984)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex985 = (decoder.readIndex()); + if (unionIndex985 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(985, null); + } else { + if (unionIndex985 == 1) { + Utf8 charSequence985; + Object oldString985 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(985); + if (oldString985 instanceof Utf8) { + charSequence985 = (decoder).readString(((Utf8) oldString985)); + } else { + charSequence985 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(985, charSequence985); + } else { + throw new RuntimeException(("Illegal union index for 'F985': "+ unionIndex985)); + } + } + int unionIndex986 = (decoder.readIndex()); + if (unionIndex986 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(986, null); + } else { + if (unionIndex986 == 1) { + Utf8 charSequence986; + Object oldString986 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(986); + if (oldString986 instanceof Utf8) { + charSequence986 = (decoder).readString(((Utf8) oldString986)); + } else { + charSequence986 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(986, charSequence986); + } else { + throw new RuntimeException(("Illegal union index for 'F986': "+ unionIndex986)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex987 = (decoder.readIndex()); + if (unionIndex987 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(987, null); + } else { + if (unionIndex987 == 1) { + Utf8 charSequence987; + Object oldString987 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(987); + if (oldString987 instanceof Utf8) { + charSequence987 = (decoder).readString(((Utf8) oldString987)); + } else { + charSequence987 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(987, charSequence987); + } else { + throw new RuntimeException(("Illegal union index for 'F987': "+ unionIndex987)); + } + } + int unionIndex988 = (decoder.readIndex()); + if (unionIndex988 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(988, null); + } else { + if (unionIndex988 == 1) { + Utf8 charSequence988; + Object oldString988 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(988); + if (oldString988 instanceof Utf8) { + charSequence988 = (decoder).readString(((Utf8) oldString988)); + } else { + charSequence988 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(988, charSequence988); + } else { + throw new RuntimeException(("Illegal union index for 'F988': "+ unionIndex988)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex989 = (decoder.readIndex()); + if (unionIndex989 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(989, null); + } else { + if (unionIndex989 == 1) { + Utf8 charSequence989; + Object oldString989 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(989); + if (oldString989 instanceof Utf8) { + charSequence989 = (decoder).readString(((Utf8) oldString989)); + } else { + charSequence989 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(989, charSequence989); + } else { + throw new RuntimeException(("Illegal union index for 'F989': "+ unionIndex989)); + } + } + int unionIndex990 = (decoder.readIndex()); + if (unionIndex990 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(990, null); + } else { + if (unionIndex990 == 1) { + Utf8 charSequence990; + Object oldString990 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(990); + if (oldString990 instanceof Utf8) { + charSequence990 = (decoder).readString(((Utf8) oldString990)); + } else { + charSequence990 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(990, charSequence990); + } else { + throw new RuntimeException(("Illegal union index for 'F990': "+ unionIndex990)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex991 = (decoder.readIndex()); + if (unionIndex991 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(991, null); + } else { + if (unionIndex991 == 1) { + Utf8 charSequence991; + Object oldString991 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(991); + if (oldString991 instanceof Utf8) { + charSequence991 = (decoder).readString(((Utf8) oldString991)); + } else { + charSequence991 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(991, charSequence991); + } else { + throw new RuntimeException(("Illegal union index for 'F991': "+ unionIndex991)); + } + } + int unionIndex992 = (decoder.readIndex()); + if (unionIndex992 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(992, null); + } else { + if (unionIndex992 == 1) { + Utf8 charSequence992; + Object oldString992 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(992); + if (oldString992 instanceof Utf8) { + charSequence992 = (decoder).readString(((Utf8) oldString992)); + } else { + charSequence992 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(992, charSequence992); + } else { + throw new RuntimeException(("Illegal union index for 'F992': "+ unionIndex992)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex993 = (decoder.readIndex()); + if (unionIndex993 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(993, null); + } else { + if (unionIndex993 == 1) { + Utf8 charSequence993; + Object oldString993 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(993); + if (oldString993 instanceof Utf8) { + charSequence993 = (decoder).readString(((Utf8) oldString993)); + } else { + charSequence993 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(993, charSequence993); + } else { + throw new RuntimeException(("Illegal union index for 'F993': "+ unionIndex993)); + } + } + int unionIndex994 = (decoder.readIndex()); + if (unionIndex994 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(994, null); + } else { + if (unionIndex994 == 1) { + Utf8 charSequence994; + Object oldString994 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(994); + if (oldString994 instanceof Utf8) { + charSequence994 = (decoder).readString(((Utf8) oldString994)); + } else { + charSequence994 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(994, charSequence994); + } else { + throw new RuntimeException(("Illegal union index for 'F994': "+ unionIndex994)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex995 = (decoder.readIndex()); + if (unionIndex995 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(995, null); + } else { + if (unionIndex995 == 1) { + Utf8 charSequence995; + Object oldString995 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(995); + if (oldString995 instanceof Utf8) { + charSequence995 = (decoder).readString(((Utf8) oldString995)); + } else { + charSequence995 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(995, charSequence995); + } else { + throw new RuntimeException(("Illegal union index for 'F995': "+ unionIndex995)); + } + } + int unionIndex996 = (decoder.readIndex()); + if (unionIndex996 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(996, null); + } else { + if (unionIndex996 == 1) { + Utf8 charSequence996; + Object oldString996 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(996); + if (oldString996 instanceof Utf8) { + charSequence996 = (decoder).readString(((Utf8) oldString996)); + } else { + charSequence996 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(996, charSequence996); + } else { + throw new RuntimeException(("Illegal union index for 'F996': "+ unionIndex996)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex997 = (decoder.readIndex()); + if (unionIndex997 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(997, null); + } else { + if (unionIndex997 == 1) { + Utf8 charSequence997; + Object oldString997 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(997); + if (oldString997 instanceof Utf8) { + charSequence997 = (decoder).readString(((Utf8) oldString997)); + } else { + charSequence997 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(997, charSequence997); + } else { + throw new RuntimeException(("Illegal union index for 'F997': "+ unionIndex997)); + } + } + int unionIndex998 = (decoder.readIndex()); + if (unionIndex998 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(998, null); + } else { + if (unionIndex998 == 1) { + Utf8 charSequence998; + Object oldString998 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(998); + if (oldString998 instanceof Utf8) { + charSequence998 = (decoder).readString(((Utf8) oldString998)); + } else { + charSequence998 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(998, charSequence998); + } else { + throw new RuntimeException(("Illegal union index for 'F998': "+ unionIndex998)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex999 = (decoder.readIndex()); + if (unionIndex999 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(999, null); + } else { + if (unionIndex999 == 1) { + Utf8 charSequence999; + Object oldString999 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(999); + if (oldString999 instanceof Utf8) { + charSequence999 = (decoder).readString(((Utf8) oldString999)); + } else { + charSequence999 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(999, charSequence999); + } else { + throw new RuntimeException(("Illegal union index for 'F999': "+ unionIndex999)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java new file mode 100644 index 000000000..ea1191de2 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testString0; + private final Schema testStringUnionAlias0; + + public FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testString0 = readerSchema.getField("testString").schema(); + this.testStringUnionAlias0 = readerSchema.getField("testStringUnionAlias").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadAliasedField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadAliasedField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadAliasedField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadAliasedField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadAliasedField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldReadAliasedField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'testString': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0((FastGenericDeserializerGeneratorTest_shouldReadAliasedField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadAliasedField; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadAliasedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(1, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadAliasedField.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnionAlias': "+ unionIndex1)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java new file mode 100644 index 000000000..ef941ca69 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847.java @@ -0,0 +1,122 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Schema testEnumUnion0; + private final Schema testEnumArray0; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadEnum = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadEnum = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(0, new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get((decoder.readEnum())))); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum1((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(1, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(1, new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get((decoder.readEnum())))); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadEnum.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + testEnumArray1 .clear(); + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadEnum.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + testEnumUnionArray1 .clear(); + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testFixed0; + private final Schema testFixedUnion0; + private final Schema testFixedArray0; + private final Schema testFixedUnionArray0; + private final Schema testFixedUnionArrayArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadFixed_GenericDeserializer_1590965143_1590965143(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testFixed0 = readerSchema.getField("testFixed").schema(); + this.testFixedUnion0 = readerSchema.getField("testFixedUnion").schema(); + this.testFixedArray0 = readerSchema.getField("testFixedArray").schema(); + this.testFixedUnionArray0 = readerSchema.getField("testFixedUnionArray").schema(); + this.testFixedUnionArrayArrayElemSchema0 = testFixedUnionArray0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadFixed = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadFixed = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + byte[] testFixed1; + Object oldFixed0 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(0); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (2))) { + testFixed1 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed1 = ( new byte[2]); + } + decoder.readFixed(testFixed1); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(0, new org.apache.avro.generic.GenericData.Fixed(testFixed0, testFixed1)); + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed1((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadFixed; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(1, null); + } else { + if (unionIndex0 == 1) { + byte[] testFixed2; + Object oldFixed1 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(1); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (2))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[2]); + } + decoder.readFixed(testFixed2); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(1, new org.apache.avro.generic.GenericData.Fixed(testFixed0, testFixed2)); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex0)); + } + } + List testFixedArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(2); + if (oldArray0 instanceof List) { + testFixedArray1 = ((List) oldArray0); + testFixedArray1 .clear(); + } else { + testFixedArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testFixedArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(3); + if (oldArray1 instanceof List) { + testFixedUnionArray1 = ((List) oldArray1); + testFixedUnionArray1 .clear(); + } else { + testFixedUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testFixedUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema union0; + private final Schema unionOptionSchema0; + private final Schema subField0; + + public FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion_GenericDeserializer_2643982_2643982(Schema readerSchema) { + this.readerSchema = readerSchema; + this.union0 = readerSchema.getField("union").schema(); + this.unionOptionSchema0 = union0 .getTypes().get(1); + this.subField0 = unionOptionSchema0 .getField("subField").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, charSequence1); + } else { + if (unionIndex0 == 3) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + } + return FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == unionOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(unionOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java new file mode 100644 index 000000000..9e384f177 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java @@ -0,0 +1,129 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema mapField0; + private final Schema mapFieldMapValueSchema0; + private final Schema mapFieldValueMapValueSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapField0 = readerSchema.getField("mapField").schema(); + this.mapFieldMapValueSchema0 = mapField0 .getValueType(); + this.mapFieldValueMapValueSchema0 = mapFieldMapValueSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadNestedMap; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadNestedMap = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadNestedMap = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map>> mapField1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), ((int) chunkLen0))); + } else { + Map>> mapFieldReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0); + if (oldMap0 instanceof Map) { + mapFieldReuse0 = ((Map) oldMap0); + } + if (mapFieldReuse0 != (null)) { + mapFieldReuse0 .clear(); + mapField1 = mapFieldReuse0; + } else { + mapField1 = new HashMap>>(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 > mapFieldValue0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, ((int) chunkLen1))); + } else { + Map> mapFieldValueReuse0 = null; + if (null instanceof Map) { + mapFieldValueReuse0 = ((Map) null); + } + if (mapFieldValueReuse0 != (null)) { + mapFieldValueReuse0 .clear(); + mapFieldValue0 = mapFieldValueReuse0; + } else { + mapFieldValue0 = new HashMap>(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0) { + for (int counter2 = 0; (counter2 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, 0)); + } else { + mapFieldValue0 = new HashMap>(0); + } + } + mapField1 .put(key0, mapFieldValue0); + } + chunkLen0 = (decoder.mapNext()); + } while (chunkLen0 > 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), 0)); + } else { + mapField1 = new HashMap>>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadNestedMap.put(0, mapField1); + return FastGenericDeserializerGeneratorTest_shouldReadNestedMap; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java new file mode 100644 index 000000000..3534a298d --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java @@ -0,0 +1,206 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + private final Schema testEnumUnion0; + private final Map enumMappingtestEnum1; + private final Schema testEnumArray0; + private final Map enumMappingtestEnum2; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + private final Map enumMappingtestEnum3; + + public FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(5); + tempEnumMapping0 .put(new Integer(0), new Integer(1)); + tempEnumMapping0 .put(new Integer(1), new Integer(0)); + tempEnumMapping0 .put(new Integer(2), new Integer(4)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + HashMap tempEnumMapping1 = new HashMap(5); + tempEnumMapping1 .put(new Integer(0), new Integer(1)); + tempEnumMapping1 .put(new Integer(1), new Integer(0)); + tempEnumMapping1 .put(new Integer(2), new Integer(4)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + HashMap tempEnumMapping2 = new HashMap(5); + tempEnumMapping2 .put(new Integer(0), new Integer(1)); + tempEnumMapping2 .put(new Integer(1), new Integer(0)); + tempEnumMapping2 .put(new Integer(2), new Integer(4)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + HashMap tempEnumMapping3 = new HashMap(5); + tempEnumMapping3 .put(new Integer(0), new Integer(1)); + tempEnumMapping3 .put(new Integer(1), new Integer(0)); + tempEnumMapping3 .put(new Integer(2), new Integer(4)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(0, enumValue0); + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum1((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(1, null); + } else { + if (unionIndex0 == 1) { + int enumIndex1 = (decoder.readEnum()); + GenericEnumSymbol enumValue1 = null; + Object enumIndexLookupResult1 = enumMappingtestEnum1 .get(enumIndex1); + if (enumIndexLookupResult1 instanceof Integer) { + enumValue1 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult1))); + } else { + if (enumIndexLookupResult1 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult1); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(1, enumValue1); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + testEnumArray1 .clear(); + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + testEnumUnionArray1 .clear(); + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testIntUnion0; + private final Schema testStringUnion0; + private final Schema testLongUnion0; + private final Schema testDoubleUnion0; + private final Schema testFloatUnion0; + private final Schema testBooleanUnion0; + private final Schema testBytesUnion0; + + public FastGenericDeserializerGeneratorTest_shouldReadPrimitives_GenericDeserializer_1966544736_1966544736(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testIntUnion0 = readerSchema.getField("testIntUnion").schema(); + this.testStringUnion0 = readerSchema.getField("testStringUnion").schema(); + this.testLongUnion0 = readerSchema.getField("testLongUnion").schema(); + this.testDoubleUnion0 = readerSchema.getField("testDoubleUnion").schema(); + this.testFloatUnion0 = readerSchema.getField("testFloatUnion").schema(); + this.testBooleanUnion0 = readerSchema.getField("testBooleanUnion").schema(); + this.testBytesUnion0 = readerSchema.getField("testBytesUnion").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(0, (decoder.readInt())); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPrimitives; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(1, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(2); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(2, charSequence0); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(3, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(3); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(3, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(4, (decoder.readLong())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(5, null); + } else { + if (unionIndex2 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(5, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex2)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(6, (decoder.readDouble())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(7, null); + } else { + if (unionIndex3 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(7, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex3)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(8, (decoder.readFloat())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(9, null); + } else { + if (unionIndex4 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(9, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex4)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(10, (decoder.readBoolean())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(11, null); + } else { + if (unionIndex5 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(11, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex5)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(12); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(12, byteBuffer0); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(13, null); + } else { + if (unionIndex6 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(13); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(13, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex6)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java new file mode 100644 index 000000000..1261ffa76 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java @@ -0,0 +1,160 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema record10; + private final Schema subField0; + private final Schema intFieldField0; + private final Schema intField0; + private final Schema subField1; + private final Schema recordArray0; + + public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record10 = readerSchema.getField("record1").schema(); + this.subField0 = record10 .getField("subField").schema(); + this.intFieldField0 = record10 .getField("intField").schema(); + this.intField0 = record10 .getField("intField").schema(); + this.subField1 = record10 .getField("subField").schema(); + this.recordArray0 = readerSchema.getField("recordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == record10)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(record10); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + subRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(1); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(1, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex0)); + } + } + subRecord.put(0, null); + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord1(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); + List recordArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); + if (oldArray0 instanceof List) { + recordArray1 = ((List) oldArray0); + recordArray1 .clear(); + } else { + recordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema record10; + private final Schema subField0; + private final Schema record20; + private final Schema intField0; + private final Schema subField1; + private final Schema recordArray0; + + public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1365753944_1274815349(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record10 = readerSchema.getField("record1").schema(); + this.subField0 = record10 .getField("subField").schema(); + this.record20 = readerSchema.getField("record2").schema(); + this.intField0 = record20 .getField("intField").schema(); + this.subField1 = record20 .getField("subField").schema(); + this.recordArray0 = readerSchema.getField("recordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializealiasedSubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializealiasedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord aliasedSubRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == record10)) { + aliasedSubRecord = ((IndexedRecord)(reuse)); + } else { + aliasedSubRecord = new org.apache.avro.generic.GenericData.Record(record10); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + decoder.readInt(); + } else { + throw new RuntimeException(("Illegal union index for 'intField': "+ unionIndex0)); + } + } + populate_aliasedSubRecord0((aliasedSubRecord), (customization), (decoder)); + return aliasedSubRecord; + } + + private void populate_aliasedSubRecord0(IndexedRecord aliasedSubRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + aliasedSubRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = aliasedSubRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + aliasedSubRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); + List recordArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); + if (oldArray0 instanceof List) { + recordArray1 = ((List) oldArray0); + recordArray1 .clear(); + } else { + recordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema recordsArray0; + private final Schema recordsArrayArrayElemSchema0; + private final Schema subField0; + private final Schema recordsMap0; + private final Schema recordsArrayUnion0; + private final Schema recordsArrayUnionOptionSchema0; + private final Schema recordsArrayUnionOptionArrayElemSchema0; + private final Schema recordsMapUnion0; + private final Schema recordsMapUnionOptionSchema0; + private final Schema recordsMapUnionOptionMapValueSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField_GenericDeserializer_1602399407_1602399407(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordsArray0 = readerSchema.getField("recordsArray").schema(); + this.recordsArrayArrayElemSchema0 = recordsArray0 .getElementType(); + this.subField0 = recordsArrayArrayElemSchema0 .getField("subField").schema(); + this.recordsMap0 = readerSchema.getField("recordsMap").schema(); + this.recordsArrayUnion0 = readerSchema.getField("recordsArrayUnion").schema(); + this.recordsArrayUnionOptionSchema0 = recordsArrayUnion0 .getTypes().get(1); + this.recordsArrayUnionOptionArrayElemSchema0 = recordsArrayUnionOptionSchema0 .getElementType(); + this.recordsMapUnion0 = readerSchema.getField("recordsMapUnion").schema(); + this.recordsMapUnionOptionSchema0 = recordsMapUnion0 .getTypes().get(1); + this.recordsMapUnionOptionMapValueSchema0 = recordsMapUnionOptionSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List recordsArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(0); + if (oldArray0 instanceof List) { + recordsArray1 = ((List) oldArray0); + recordsArray1 .clear(); + } else { + recordsArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordsArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 recordsMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), ((int) chunkLen1))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap1 = recordsMapReuse0; + } else { + recordsMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), 0)); + } else { + recordsMap1 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(1, recordsMap1); + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(2, null); + } else { + if (unionIndex1 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(2); + if (oldArray1 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray1); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen2), recordsArrayUnionOptionSchema0); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 recordsMapUnionOption0 = null; + long chunkLen3 = (decoder.readMapStart()); + if (chunkLen3 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), ((int) chunkLen3))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); + } + } + do { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(3, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex3)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java new file mode 100644 index 000000000..3cb65717a --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java @@ -0,0 +1,378 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema recordsArrayMap0; + private final Schema recordsArrayMapArrayElemSchema0; + private final Schema recordsArrayMapElemMapValueSchema0; + private final Schema recordsArrayMapElemValueOptionSchema0; + private final Schema subField0; + private final Schema recordsMapArray0; + private final Schema recordsMapArrayMapValueSchema0; + private final Schema recordsMapArrayValueArrayElemSchema0; + private final Schema recordsArrayMapUnion0; + private final Schema recordsArrayMapUnionOptionArrayElemSchema0; + private final Schema recordsArrayMapUnionOptionElemMapValueSchema0; + private final Schema recordsMapArrayUnion0; + private final Schema recordsMapArrayUnionOptionSchema0; + private final Schema recordsMapArrayUnionOptionValueArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordsArrayMap0 = readerSchema.getField("recordsArrayMap").schema(); + this.recordsArrayMapArrayElemSchema0 = recordsArrayMap0 .getElementType(); + this.recordsArrayMapElemMapValueSchema0 = recordsArrayMapArrayElemSchema0 .getValueType(); + this.recordsArrayMapElemValueOptionSchema0 = recordsArrayMapElemMapValueSchema0 .getTypes().get(1); + this.subField0 = recordsArrayMapElemValueOptionSchema0 .getField("subField").schema(); + this.recordsMapArray0 = readerSchema.getField("recordsMapArray").schema(); + this.recordsMapArrayMapValueSchema0 = recordsMapArray0 .getValueType(); + this.recordsMapArrayValueArrayElemSchema0 = recordsMapArrayMapValueSchema0 .getElementType(); + this.recordsArrayMapUnion0 = readerSchema.getField("recordsArrayMapUnion").schema(); + this.recordsArrayMapUnionOptionArrayElemSchema0 = recordsArrayMap0 .getElementType(); + this.recordsArrayMapUnionOptionElemMapValueSchema0 = recordsArrayMapUnionOptionArrayElemSchema0 .getValueType(); + this.recordsMapArrayUnion0 = readerSchema.getField("recordsMapArrayUnion").schema(); + this.recordsMapArrayUnionOptionSchema0 = recordsMapArrayUnion0 .getTypes().get(1); + this.recordsMapArrayUnionOptionValueArrayElemSchema0 = recordsMapArrayMapValueSchema0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List> recordsArrayMap1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(0); + if (oldArray0 instanceof List) { + recordsArrayMap1 = ((List) oldArray0); + recordsArrayMap1 .clear(); + } else { + recordsArrayMap1 = new org.apache.avro.generic.GenericData.Array>(((int) chunkLen0), recordsArrayMap0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 recordsArrayMapElem0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen1))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap1 .add(recordsArrayMapElem0); + } + chunkLen0 = (decoder.arrayNext()); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(0, recordsArrayMap1); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordsArrayMapElemValueOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(recordsArrayMapElemValueOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray1 = null; + long chunkLen2 = (decoder.readMapStart()); + if (chunkLen2 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), ((int) chunkLen2))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap0); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray1 = recordsMapArrayReuse0; + } else { + recordsMapArray1 = new HashMap>(((int)(((chunkLen2 * 4)+ 2)/ 3))); + } + } + do { + for (int counter2 = 0; (counter2 recordsMapArrayValue0 = null; + long chunkLen3 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen3), recordsMapArrayMapValueSchema0); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), 0)); + } else { + recordsMapArray1 = new HashMap>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(1, recordsMapArray1); + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(2, null); + } else { + if (unionIndex3 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(2); + if (oldArray1 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray1); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new org.apache.avro.generic.GenericData.Array>(((int) chunkLen4), recordsArrayMap0); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArrayMapUnionOptionElem0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen5))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen4 = (decoder.arrayNext()); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(2, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex3)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(3, null); + } else { + if (unionIndex5 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), ((int) chunkLen6))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 recordsMapArrayUnionOptionValue0 = null; + long chunkLen7 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen7), recordsMapArrayMapValueSchema0); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(3, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex5)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java new file mode 100644 index 000000000..406daccef --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java @@ -0,0 +1,114 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema record0; + private final Schema recordOptionSchema0; + private final Schema subField0; + private final Schema field0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record0 = readerSchema.getField("record").schema(); + this.recordOptionSchema0 = record0 .getTypes().get(1); + this.subField0 = recordOptionSchema0 .getField("subField").schema(); + this.field0 = readerSchema.getField("field").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'record': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(recordOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(1), (decoder), (customization))); + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(2, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(2); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(2, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex2)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java new file mode 100644 index 000000000..f196fafd1 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java @@ -0,0 +1,252 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testNotRemoved0; + private final Schema testNotRemoved20; + private final Schema subRecord0; + private final Schema subRecordOptionSchema0; + private final Schema testNotRemoved1; + private final Schema testNotRemoved21; + private final Schema subRecordMap0; + private final Schema subRecordArray0; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testNotRemoved0 = readerSchema.getField("testNotRemoved").schema(); + this.testNotRemoved20 = readerSchema.getField("testNotRemoved2").schema(); + this.subRecord0 = readerSchema.getField("subRecord").schema(); + this.subRecordOptionSchema0 = subRecord0 .getTypes().get(1); + this.testNotRemoved1 = subRecordOptionSchema0 .getField("testNotRemoved").schema(); + this.testNotRemoved21 = subRecordOptionSchema0 .getField("testNotRemoved2").schema(); + this.subRecordMap0 = readerSchema.getField("subRecordMap").schema(); + this.subRecordArray0 = readerSchema.getField("subRecordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + } else { + if (unionIndex1 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testRemoved': "+ unionIndex1)); + } + } + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(1, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved2': "+ unionIndex2)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, null); + } else { + if (unionIndex3 == 1) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(2), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex3)); + } + } + Map subRecordMap1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), ((int) chunkLen0))); + } else { + Map subRecordMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3); + if (oldMap0 instanceof Map) { + subRecordMapReuse0 = ((Map) oldMap0); + } + if (subRecordMapReuse0 != (null)) { + subRecordMapReuse0 .clear(); + subRecordMap1 = subRecordMapReuse0; + } else { + subRecordMap1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), 0)); + } else { + subRecordMap1 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(3, subRecordMap1); + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecordOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecordOptionSchema0); + } + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex4 == 1) { + Utf8 charSequence2; + Object oldString2 = subRecord.get(0); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + subRecord.put(0, charSequence2); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex4)); + } + } + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + } else { + if (unionIndex5 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testRemoved': "+ unionIndex5)); + } + } + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + subRecord.put(1, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence3; + Object oldString3 = subRecord.get(1); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + subRecord.put(1, charSequence3); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved2': "+ unionIndex6)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List subRecordArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(4); + if (oldArray0 instanceof List) { + subRecordArray1 = ((List) oldArray0); + subRecordArray1 .clear(); + } else { + subRecordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), subRecordArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema subRecord0; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord_GenericDeserializer_1090641932_438987109(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.get(0), (decoder), (customization))); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord0); + } + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + populate_subRecord0((subRecord), (customization), (decoder)); + populate_subRecord1((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubSubRecord0(null, (decoder), (customization)); + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + deserializesubSubRecord0(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'test3': "+ unionIndex0)); + } + } + } + + public void deserializesubSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + populate_subSubRecord0((decoder)); + } + + private void populate_subSubRecord0(Decoder decoder) + throws IOException + { + decoder.skipString(); + } + + private void populate_subRecord1(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = subRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + subRecord.put(1, charSequence1); + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java new file mode 100644 index 000000000..2e9ed90b7 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java @@ -0,0 +1,114 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema subRecord10; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord10 = readerSchema.getField("subRecord1").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord10)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord10); + } + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = subRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + subRecord.put(1, charSequence1); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubRecord20(null, (decoder), (customization)); + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + deserializesubRecord20(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord3': "+ unionIndex0)); + } + } + } + + public void deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + populate_subRecord20((decoder)); + } + + private void populate_subRecord20(Decoder decoder) + throws IOException + { + decoder.skipString(); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(1), (decoder), (customization))); + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java new file mode 100644 index 000000000..5dd0a56cf --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java @@ -0,0 +1,60 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java new file mode 100644 index 000000000..4732caebf --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java @@ -0,0 +1,60 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java new file mode 100644 index 000000000..9425e4e38 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + throw new AvroTypeException("Found \"long\", expecting [\"null\", \"string\"]"); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java new file mode 100644 index 000000000..269467a74 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java new file mode 100644 index 000000000..dea694bbc --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java new file mode 100644 index 000000000..2b482c9b5 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java new file mode 100644 index 000000000..652b6df84 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java new file mode 100644 index 000000000..397323d34 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java new file mode 100644 index 000000000..d5555accd --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java @@ -0,0 +1,71 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_906204958(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_1778260273(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.put(0, null); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_906204958(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.put(0, null); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_2127585735(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + if (unionIndex0 == 1) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java new file mode 100644 index 000000000..d2526e5b7 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + if (unionIndex0 == 1) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java new file mode 100644 index 000000000..a3198ff04 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + if (unionIndex0 == 1) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java new file mode 100644 index 000000000..0073d95f1 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + if (unionIndex0 == 1) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java new file mode 100644 index 000000000..78db76ccd --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java new file mode 100644 index 000000000..ed1be6564 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java new file mode 100644 index 000000000..27e37778c --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java new file mode 100644 index 000000000..858f62ae3 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java new file mode 100644 index 000000000..51c12e833 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + this.testOptionSchema1 = test0 .getTypes().get(2); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java new file mode 100644 index 000000000..1085301ae --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + this.testOptionSchema1 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java new file mode 100644 index 000000000..db6ef95ef --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(2); + this.testOptionSchema1 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java new file mode 100644 index 000000000..6f1ca2ef5 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + this.testOptionSchema1 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java new file mode 100644 index 000000000..b2dc6214d --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569.java @@ -0,0 +1,148 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyInReaderSchemaTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyInReaderSchemaTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence1; + Object oldString1 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + testStringArray1 .clear(); + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java new file mode 100644 index 000000000..b2191c04d --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java @@ -0,0 +1,130 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyInReaderSchemaTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyInReaderSchemaTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + String charSequence0 = (decoder).readString(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, null); + } else { + if (unionIndex0 == 1) { + String charSequence1 = (decoder).readString(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + testStringArray1 .clear(); + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java new file mode 100644 index 000000000..4364e0e88 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java @@ -0,0 +1,130 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + String charSequence0 = (decoder).readString(); + FastStringableTest_javaStringPropertyTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyTest0((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyTest1((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyTest; + } + + private void populate_FastStringableTest_javaStringPropertyTest0(IndexedRecord FastStringableTest_javaStringPropertyTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyTest.put(1, null); + } else { + if (unionIndex0 == 1) { + String charSequence1 = (decoder).readString(); + FastStringableTest_javaStringPropertyTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + testStringArray1 .clear(); + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java new file mode 100644 index 000000000..71ee175cd --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java @@ -0,0 +1,1071 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex7 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex7)); + } + } + List testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema mapMapValueSchema0; + private final Schema mapValueOptionSchema0; + private final Schema field0; + + public Map_of_UNION_GenericDeserializer_2140000109_2140000109(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapValueSchema0 = readerSchema.getValueType(); + this.mapValueOptionSchema0 = mapMapValueSchema0 .getTypes().get(1); + this.field0 = mapValueOptionSchema0 .getField("field").schema(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapValueOptionSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapValueOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + record.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = record.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + record.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex1)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/Map_of_UNION_SpecificDeserializer_971650236_971650236.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/Map_of_UNION_SpecificDeserializer_971650236_971650236.java new file mode 100644 index 000000000..bee8d45c3 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/Map_of_UNION_SpecificDeserializer_971650236_971650236.java @@ -0,0 +1,1081 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_UNION_SpecificDeserializer_971650236_971650236 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Map_of_UNION_SpecificDeserializer_971650236_971650236(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex1)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex2)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex3)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex4)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex5 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex5)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex6 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex6)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex7 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex7)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + List testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex15 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex17)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex21 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex21)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex23 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex23)); + } + } + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex25 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex25 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex25 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex25)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema unionOptionMapValueSchema0; + + public Map_of_record_GenericDeserializer_1223705675_568621313(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOptionMapValueSchema0 = readerSchema.getValueType(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":{\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}}"); + } else { + if (unionIndex0 == 1) { + Map unionOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map unionOptionReuse0 = null; + if ((reuse) instanceof Map) { + unionOptionReuse0 = ((Map)(reuse)); + } + if (unionOptionReuse0 != (null)) { + unionOptionReuse0 .clear(); + unionOption0 = unionOptionReuse0; + } else { + unionOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + unionOption0 = new HashMap(0); + } + } + return unionOption0; + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == unionOptionMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(unionOptionMapValueSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/Map_of_record_GenericDeserializer_1677529043_1677529043.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/Map_of_record_GenericDeserializer_1677529043_1677529043.java new file mode 100644 index 000000000..281fe9212 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/Map_of_record_GenericDeserializer_1677529043_1677529043.java @@ -0,0 +1,95 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_record_GenericDeserializer_1677529043_1677529043 + implements FastDeserializer> +{ + + private final Schema readerSchema; + private final Schema mapMapValueSchema0; + private final Schema field0; + + public Map_of_record_GenericDeserializer_1677529043_1677529043(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapValueSchema0 = readerSchema.getValueType(); + this.field0 = mapMapValueSchema0 .getField("field").schema(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapMapValueSchema0); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + record.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = record.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + record.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java new file mode 100644 index 000000000..e804ac3e0 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java @@ -0,0 +1,61 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserialize(com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRecordWithLargeUnionField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserializeRecordWithLargeUnionField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField RecordWithLargeUnionField; + if ((reuse)!= null) { + RecordWithLargeUnionField = ((com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField)(reuse)); + } else { + RecordWithLargeUnionField = new com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Utf8 charSequence0; + Object oldString0 = RecordWithLargeUnionField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RecordWithLargeUnionField.put(0, charSequence0); + } else { + if (unionIndex0 == 1) { + RecordWithLargeUnionField.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + throw new AvroTypeException(new StringBuilder().append("Found").append(" \"byt").append("es\", ").append("expec").append("ting ").append("[\"str").append("ing\",").append(" \"int").append("\"]").toString()); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + } + return RecordWithLargeUnionField; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java new file mode 100644 index 000000000..a9a4c0da3 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java @@ -0,0 +1,47 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; + if ((reuse)!= null) { + RemovedTypesTestRecord = ((com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord)(reuse)); + } else { + RemovedTypesTestRecord = new com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord(); + } + Utf8 charSequence0; + Object oldString0 = RemovedTypesTestRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RemovedTypesTestRecord.put(0, charSequence0); + return RemovedTypesTestRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java new file mode 100644 index 000000000..bee5afceb --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java @@ -0,0 +1,406 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; + if ((reuse)!= null) { + RemovedTypesTestRecord = ((com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord)(reuse)); + } else { + RemovedTypesTestRecord = new com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord(); + } + Utf8 charSequence0; + Object oldString0 = RemovedTypesTestRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RemovedTypesTestRecord.put(0, charSequence0); + populate_RemovedTypesTestRecord0((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord1((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord2((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord3((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord4((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord5((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord6((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord7((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord8((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord9((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord10((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord11((RemovedTypesTestRecord), (customization), (decoder)); + return RemovedTypesTestRecord; + } + + private void populate_RemovedTypesTestRecord0(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.skipBytes(); + long chunkLen0 = (decoder.readArrayStart()); + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 0) { + do { + for (int counter1 = 0; (counter1 0); + } + } + + private void populate_RemovedTypesTestRecord2(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen2 = (decoder.readArrayStart()); + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 0) { + do { + for (int counter3 = 0; (counter3 0); + } + } + + private void populate_RemovedTypesTestRecord3(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.skipFixed(1); + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + } else { + if (unionIndex3 == 1) { + decoder.skipFixed(1); + } else { + throw new RuntimeException(("Illegal union index for 'removedFixedUnion': "+ unionIndex3)); + } + } + } + + private void populate_RemovedTypesTestRecord4(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen4 = (decoder.readArrayStart()); + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 0) { + do { + for (int counter5 = 0; (counter5 0); + } + } + + private void populate_RemovedTypesTestRecord5(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen6 = (decoder.readArrayStart()); + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 0) { + do { + for (int counter7 = 0; (counter7 0); + } + } + + private void populate_RemovedTypesTestRecord6(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.readEnum(); + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + } else { + if (unionIndex6 == 1) { + decoder.readEnum(); + } else { + throw new RuntimeException(("Illegal union index for 'removedEnumUnion': "+ unionIndex6)); + } + } + } + + private void populate_RemovedTypesTestRecord7(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen8 = (decoder.readArrayStart()); + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 0) { + do { + for (int counter9 = 0; (counter9 0); + } + } + + private void populate_RemovedTypesTestRecord8(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen10 = (decoder.readArrayStart()); + while (chunkLen10 > 0) { + for (int counter10 = 0; (counter10 0) { + do { + for (int counter11 = 0; (counter11 0); + } + } + + private void populate_RemovedTypesTestRecord9(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializeRemovedSubRecord0(null, (decoder), (customization)); + int unionIndex9 = (decoder.readIndex()); + if (unionIndex9 == 0) { + decoder.readNull(); + } else { + if (unionIndex9 == 1) { + deserializeRemovedSubRecord0(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'removedSubRecordUnion': "+ unionIndex9)); + } + } + } + + public void deserializeRemovedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + } + + private void populate_RemovedTypesTestRecord10(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen12 = (decoder.readArrayStart()); + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0) { + for (int counter13 = 0; (counter13 0) { + do { + for (int counter14 = 0; (counter14 0); + } + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + do { + for (int counter15 = 0; (counter15 0); + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java new file mode 100644 index 000000000..4c21188b2 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java @@ -0,0 +1,172 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class SplitRecordTest1_SpecificDeserializer_1718878379_595582209 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public SplitRecordTest1_SpecificDeserializer_1718878379_595582209(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeSplitRecordTest10((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserializeSplitRecordTest10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 SplitRecordTest1; + if ((reuse)!= null) { + SplitRecordTest1 = ((com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1)(reuse)); + } else { + SplitRecordTest1 = new com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1(); + } + SplitRecordTest1 .put(0, deserializeFullRecord0(SplitRecordTest1 .get(0), (decoder), (customization))); + populate_SplitRecordTest10((SplitRecordTest1), (customization), (decoder)); + return SplitRecordTest1; + } + + public com.linkedin.avro.fastserde.generated.avro.FullRecord deserializeFullRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.FullRecord FullRecord; + if ((reuse)!= null) { + FullRecord = ((com.linkedin.avro.fastserde.generated.avro.FullRecord)(reuse)); + } else { + FullRecord = new com.linkedin.avro.fastserde.generated.avro.FullRecord(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FullRecord.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FullRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FullRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex0)); + } + } + FullRecord.put(1, null); + return FullRecord; + } + + private void populate_SplitRecordTest10(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 SplitRecordTest1, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + SplitRecordTest1 .put(1, deserializeFullRecord1(SplitRecordTest1 .get(1), (decoder), (customization))); + List record30 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = SplitRecordTest1 .get(2); + if (oldArray0 instanceof List) { + record30 = ((List) oldArray0); + record30 .clear(); + } else { + record30 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public SplitRecordTest2_SpecificDeserializer_595582209_1718878379(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeSplitRecordTest20((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserializeSplitRecordTest20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 SplitRecordTest2; + if ((reuse)!= null) { + SplitRecordTest2 = ((com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2)(reuse)); + } else { + SplitRecordTest2 = new com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2(); + } + SplitRecordTest2 .put(0, deserializeStringRecord0(SplitRecordTest2 .get(0), (decoder), (customization))); + populate_SplitRecordTest20((SplitRecordTest2), (customization), (decoder)); + return SplitRecordTest2; + } + + public StringRecord deserializeStringRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + StringRecord IntRecord; + if ((reuse)!= null) { + IntRecord = ((StringRecord)(reuse)); + } else { + IntRecord = new StringRecord(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + IntRecord.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = IntRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + IntRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex0)); + } + } + populate_IntRecord0((IntRecord), (customization), (decoder)); + return IntRecord; + } + + private void populate_IntRecord0(StringRecord IntRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + } else { + if (unionIndex1 == 1) { + decoder.readInt(); + } else { + throw new RuntimeException(("Illegal union index for 'field2': "+ unionIndex1)); + } + } + } + + private void populate_SplitRecordTest20(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 SplitRecordTest2, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + SplitRecordTest2 .put(1, deserializeIntRecord0(SplitRecordTest2 .get(1), (decoder), (customization))); + List record30 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = SplitRecordTest2 .get(2); + if (oldArray0 instanceof List) { + record30 = ((List) oldArray0); + record30 .clear(); + } else { + record30 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public StringableRecord_SpecificDeserializer_842267318_842267318(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserialize(com.linkedin.avro.fastserde.generated.avro.StringableRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + try { + return deserializeStringableRecord0((reuse), (decoder), (customization)); + } catch (NumberFormatException e) { + throw new AvroRuntimeException(e); + } catch (MalformedURLException e) { + throw new AvroRuntimeException(e); + } catch (URISyntaxException e) { + throw new AvroRuntimeException(e); + } + } + + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserializeStringableRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord; + if ((reuse)!= null) { + StringableRecord = ((com.linkedin.avro.fastserde.generated.avro.StringableRecord)(reuse)); + } else { + StringableRecord = new com.linkedin.avro.fastserde.generated.avro.StringableRecord(); + } + BigInteger charSequence0 = new BigInteger((decoder.readString())); + StringableRecord.put(0, charSequence0); + populate_StringableRecord0((StringableRecord), (customization), (decoder)); + populate_StringableRecord1((StringableRecord), (customization), (decoder)); + populate_StringableRecord2((StringableRecord), (customization), (decoder)); + populate_StringableRecord3((StringableRecord), (customization), (decoder)); + populate_StringableRecord4((StringableRecord), (customization), (decoder)); + return StringableRecord; + } + + private void populate_StringableRecord0(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, URISyntaxException + { + BigDecimal charSequence1 = new BigDecimal((decoder.readString())); + StringableRecord.put(1, charSequence1); + URI charSequence2 = new URI((decoder.readString())); + StringableRecord.put(2, charSequence2); + } + + private void populate_StringableRecord1(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + URL charSequence3 = new URL((decoder.readString())); + StringableRecord.put(3, charSequence3); + File charSequence4 = new File((decoder.readString())); + StringableRecord.put(4, charSequence4); + } + + private void populate_StringableRecord2(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + List urlArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = StringableRecord.get(5); + if (oldArray0 instanceof List) { + urlArray0 = ((List) oldArray0); + urlArray0 .clear(); + } else { + urlArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 urlMap0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), ((int) chunkLen1))); + } else { + Map urlMapReuse0 = null; + Object oldMap0 = StringableRecord.get(6); + if (oldMap0 instanceof Map) { + urlMapReuse0 = ((Map) oldMap0); + } + if (urlMapReuse0 != (null)) { + urlMapReuse0 .clear(); + urlMap0 = urlMapReuse0; + } else { + urlMap0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), 0)); + } else { + urlMap0 = new HashMap(0); + } + } + StringableRecord.put(6, urlMap0); + } + + private void populate_StringableRecord3(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + StringableRecord.put(7, deserializeStringableSubRecord0(StringableRecord.get(7), (decoder), (customization))); + StringableRecord.put(8, deserializeAnotherSubRecord0(StringableRecord.get(8), (decoder), (customization))); + } + + public com.linkedin.avro.fastserde.generated.avro.StringableSubRecord deserializeStringableSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException, URISyntaxException + { + com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord; + if ((reuse)!= null) { + StringableSubRecord = ((com.linkedin.avro.fastserde.generated.avro.StringableSubRecord)(reuse)); + } else { + StringableSubRecord = new com.linkedin.avro.fastserde.generated.avro.StringableSubRecord(); + } + URI charSequence7 = new URI((decoder.readString())); + StringableSubRecord.put(0, charSequence7); + populate_StringableSubRecord0((StringableSubRecord), (customization), (decoder)); + return StringableSubRecord; + } + + private void populate_StringableSubRecord0(com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, URISyntaxException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + StringableSubRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence8; + Object oldString0 = StringableSubRecord.get(1); + if (oldString0 instanceof Utf8) { + charSequence8 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence8 = (decoder).readString(null); + } + StringableSubRecord.put(1, charSequence8); + } else { + if (unionIndex0 == 2) { + StringableSubRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'nullStringIntUnion': "+ unionIndex0)); + } + } + } + } + + public com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord deserializeAnotherSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException, URISyntaxException + { + com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord AnotherSubRecord; + if ((reuse)!= null) { + AnotherSubRecord = ((com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord)(reuse)); + } else { + AnotherSubRecord = new com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord(); + } + AnotherSubRecord.put(0, deserializeStringableSubRecord0(AnotherSubRecord.get(0), (decoder), (customization))); + return AnotherSubRecord; + } + + private void populate_StringableRecord4(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + StringableRecord.put(9, null); + } else { + if (unionIndex1 == 1) { + String charSequence9 = (decoder).readString(); + StringableRecord.put(9, charSequence9); + } else { + throw new RuntimeException(("Illegal union index for 'stringUnion': "+ unionIndex1)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java new file mode 100644 index 000000000..904018c57 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java @@ -0,0 +1,46 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class TestArrayOfFloats_GenericDeserializer_1408566797_1408566797 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema array_of_float0; + + public TestArrayOfFloats_GenericDeserializer_1408566797_1408566797(Schema readerSchema) { + this.readerSchema = readerSchema; + this.array_of_float0 = readerSchema.getField("array_of_float").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestArrayOfFloats0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestArrayOfFloats0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord TestArrayOfFloats; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + TestArrayOfFloats = ((IndexedRecord)(reuse)); + } else { + TestArrayOfFloats = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + PrimitiveFloatList array_of_float1 = null; + array_of_float1 = ((PrimitiveFloatList) BufferBackedPrimitiveFloatList.readPrimitiveFloatArray(TestArrayOfFloats.get(0), (decoder))); + TestArrayOfFloats.put(0, array_of_float1); + return TestArrayOfFloats; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/TestRecord_GenericDeserializer_473555078_473555078.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/TestRecord_GenericDeserializer_473555078_473555078.java new file mode 100644 index 000000000..6b5678f41 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/TestRecord_GenericDeserializer_473555078_473555078.java @@ -0,0 +1,78 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_GenericDeserializer_473555078_473555078 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema map_field0; + + public TestRecord_GenericDeserializer_473555078_473555078(Schema readerSchema) { + this.readerSchema = readerSchema; + this.map_field0 = readerSchema.getField("map_field").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord TestRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + TestRecord = ((IndexedRecord)(reuse)); + } else { + TestRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map map_field1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), ((int) chunkLen0))); + } else { + Map map_fieldReuse0 = null; + Object oldMap0 = TestRecord.get(0); + if (oldMap0 instanceof Map) { + map_fieldReuse0 = ((Map) oldMap0); + } + if (map_fieldReuse0 != (null)) { + map_fieldReuse0 .clear(); + map_field1 = map_fieldReuse0; + } else { + map_field1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), 0)); + } else { + map_field1 = new HashMap(0); + } + } + TestRecord.put(0, map_field1); + return TestRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/TestRecord_SpecificDeserializer_1898726132_553331077.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/TestRecord_SpecificDeserializer_1898726132_553331077.java new file mode 100644 index 000000000..39625df3e --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/TestRecord_SpecificDeserializer_1898726132_553331077.java @@ -0,0 +1,1039 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_1898726132_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Map enumMappingTestEnum0; + private final Map enumMappingTestEnum1; + private final Map enumMappingTestEnum2; + private final Map enumMappingTestEnum3; + + public TestRecord_SpecificDeserializer_1898726132_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + HashMap tempEnumMapping0 = new HashMap(5); + tempEnumMapping0 .put(new Integer(0), new Integer(4)); + tempEnumMapping0 .put(new Integer(1), new Integer(3)); + tempEnumMapping0 .put(new Integer(2), new Integer(1)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + HashMap tempEnumMapping1 = new HashMap(5); + tempEnumMapping1 .put(new Integer(0), new Integer(4)); + tempEnumMapping1 .put(new Integer(1), new Integer(3)); + tempEnumMapping1 .put(new Integer(2), new Integer(1)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + HashMap tempEnumMapping2 = new HashMap(5); + tempEnumMapping2 .put(new Integer(0), new Integer(4)); + tempEnumMapping2 .put(new Integer(1), new Integer(3)); + tempEnumMapping2 .put(new Integer(2), new Integer(1)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + HashMap tempEnumMapping3 = new HashMap(5); + tempEnumMapping3 .put(new Integer(0), new Integer(4)); + tempEnumMapping3 .put(new Integer(1), new Integer(3)); + tempEnumMapping3 .put(new Integer(2), new Integer(1)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + ArrayList defaultArray0 = new ArrayList(); + TestRecord.put(33, defaultArray0); + ArrayList defaultArray1 = new ArrayList(); + TestRecord.put(34, defaultArray1); + ArrayList defaultArray2 = new ArrayList(); + TestRecord.put(35, defaultArray2); + ArrayList defaultArray3 = new ArrayList(); + TestRecord.put(36, defaultArray3); + ArrayList defaultArray4 = new ArrayList(); + TestRecord.put(37, defaultArray4); + ArrayList defaultArray5 = new ArrayList(); + TestRecord.put(38, defaultArray5); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + } else { + if (unionIndex7 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'removedField': "+ unionIndex7)); + } + } + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + } + + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + } + + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex16 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex18)); + } + } + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex22 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex24 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex24)); + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex26 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex26 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex26 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex26)); + } + } + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/TestRecord_SpecificDeserializer_1991094399_553331077.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/TestRecord_SpecificDeserializer_1991094399_553331077.java new file mode 100644 index 000000000..9172e15da --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/TestRecord_SpecificDeserializer_1991094399_553331077.java @@ -0,0 +1,1043 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_1991094399_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Map enumMappingTestEnum0; + private final Map enumMappingTestEnum1; + private final Map enumMappingTestEnum2; + private final Map enumMappingTestEnum3; + + public TestRecord_SpecificDeserializer_1991094399_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + HashMap tempEnumMapping0 = new HashMap(6); + tempEnumMapping0 .put(new Integer(0), new Integer(4)); + tempEnumMapping0 .put(new Integer(1), new Integer(3)); + tempEnumMapping0 .put(new Integer(2), new Integer(1)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(0)); + tempEnumMapping0 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + HashMap tempEnumMapping1 = new HashMap(6); + tempEnumMapping1 .put(new Integer(0), new Integer(4)); + tempEnumMapping1 .put(new Integer(1), new Integer(3)); + tempEnumMapping1 .put(new Integer(2), new Integer(1)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(0)); + tempEnumMapping1 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + HashMap tempEnumMapping2 = new HashMap(6); + tempEnumMapping2 .put(new Integer(0), new Integer(4)); + tempEnumMapping2 .put(new Integer(1), new Integer(3)); + tempEnumMapping2 .put(new Integer(2), new Integer(1)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(0)); + tempEnumMapping2 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + HashMap tempEnumMapping3 = new HashMap(6); + tempEnumMapping3 .put(new Integer(0), new Integer(4)); + tempEnumMapping3 .put(new Integer(1), new Integer(3)); + tempEnumMapping3 .put(new Integer(2), new Integer(1)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(0)); + tempEnumMapping3 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + ArrayList defaultArray0 = new ArrayList(); + TestRecord.put(33, defaultArray0); + ArrayList defaultArray1 = new ArrayList(); + TestRecord.put(34, defaultArray1); + ArrayList defaultArray2 = new ArrayList(); + TestRecord.put(35, defaultArray2); + ArrayList defaultArray3 = new ArrayList(); + TestRecord.put(36, defaultArray3); + ArrayList defaultArray4 = new ArrayList(); + TestRecord.put(37, defaultArray4); + ArrayList defaultArray5 = new ArrayList(); + TestRecord.put(38, defaultArray5); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + } else { + if (unionIndex7 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'removedField': "+ unionIndex7)); + } + } + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + } + + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + } + + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex16 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex18)); + } + } + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex22 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex24 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex24)); + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex26 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex26 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex26 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex26)); + } + } + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/TestRecord_SpecificDeserializer_553331077_553331077.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/TestRecord_SpecificDeserializer_553331077_553331077.java new file mode 100644 index 000000000..5ef4188dc --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/TestRecord_SpecificDeserializer_553331077_553331077.java @@ -0,0 +1,1040 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_553331077_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public TestRecord_SpecificDeserializer_553331077_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex7 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex7)); + } + } + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + testFixedArray0 .clear(); + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + testFixedUnionArray0 .clear(); + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + testEnumArray0 .clear(); + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + testEnumUnionArray0 .clear(); + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + recordsArray0 .clear(); + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + recordsArrayUnionOption0 .clear(); + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + recordsArrayMap0 .clear(); + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + recordsMapArrayValue0 .clear(); + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + recordsArrayMapUnionOption0 .clear(); + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + recordsMapArrayUnionOptionValue0 .clear(); + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen16 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 stringArray0 = null; + long chunkLen20 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + stringArray0 .clear(); + } else { + stringArray0 = new ArrayList(((int) chunkLen20)); + } + while (chunkLen20 > 0) { + for (int counter20 = 0; (counter20 +{ + + private final Schema readerSchema; + private final Schema recordRecordSchema0; + + public UNION_GenericDeserializer_1971822364_1672473580(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordRecordSchema0 = readerSchema.getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordRecordSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(recordRecordSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/UNION_GenericDeserializer_2018567528_1606337179.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/UNION_GenericDeserializer_2018567528_1606337179.java new file mode 100644 index 000000000..56842e7b8 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/UNION_GenericDeserializer_2018567528_1606337179.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class UNION_GenericDeserializer_2018567528_1606337179 + implements FastDeserializer> +{ + + private final Schema readerSchema; + private final Schema arrayArraySchema0; + private final Schema arrayArrayElemSchema0; + + public UNION_GenericDeserializer_2018567528_1606337179(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArraySchema0 = readerSchema.getTypes().get(1); + this.arrayArrayElemSchema0 = arrayArraySchema0 .getElementType(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + array0 .clear(); + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), arrayArraySchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + private final Schema mapMapSchema0; + private final Schema mapMapValueSchema0; + + public UNION_GenericDeserializer_568621313_1223705675(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapSchema0 = readerSchema.getTypes().get(1); + this.mapMapValueSchema0 = mapMapSchema0 .getValueType(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapMapValueSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java new file mode 100644 index 000000000..8391d6529 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.MyEnumV1; +import com.linkedin.avro.fastserde.generated.avro.MyEnumV2; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserialize(com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeUnionOfRecordsWithSameNameEnumField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserializeUnionOfRecordsWithSameNameEnumField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField UnionOfRecordsWithSameNameEnumField; + if ((reuse)!= null) { + UnionOfRecordsWithSameNameEnumField = ((com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField)(reuse)); + } else { + UnionOfRecordsWithSameNameEnumField = new com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV10(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV20(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + return UnionOfRecordsWithSameNameEnumField; + } + + public com.linkedin.avro.fastserde.generated.avro.MyRecordV1 deserializeMyRecordV10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.MyRecordV1 MyRecordV1; + if ((reuse)!= null) { + MyRecordV1 = ((com.linkedin.avro.fastserde.generated.avro.MyRecordV1)(reuse)); + } else { + MyRecordV1 = new com.linkedin.avro.fastserde.generated.avro.MyRecordV1(); + } + MyRecordV1 .put(0, Enums.getConstant(MyEnumV1 .class, (decoder.readEnum()))); + return MyRecordV1; + } + + public com.linkedin.avro.fastserde.generated.avro.MyRecordV2 deserializeMyRecordV20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.MyRecordV2 MyRecordV2; + if ((reuse)!= null) { + MyRecordV2 = ((com.linkedin.avro.fastserde.generated.avro.MyRecordV2)(reuse)); + } else { + MyRecordV2 = new com.linkedin.avro.fastserde.generated.avro.MyRecordV2(); + } + MyRecordV2 .put(0, Enums.getConstant(MyEnumV2 .class, (decoder.readEnum()))); + return MyRecordV2; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/recordName_GenericDeserializer_1743054079_1743054079.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/recordName_GenericDeserializer_1743054079_1743054079.java new file mode 100644 index 000000000..10e3a74d2 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/recordName_GenericDeserializer_1743054079_1743054079.java @@ -0,0 +1,67 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class recordName_GenericDeserializer_1743054079_1743054079 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema unionField0; + + public recordName_GenericDeserializer_1743054079_1743054079(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionField0 = readerSchema.getField("unionField").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecordName0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecordName0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord recordName; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + recordName = ((IndexedRecord)(reuse)); + } else { + recordName = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = recordName.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + recordName.put(0, charSequence0); + populate_recordName0((recordName), (customization), (decoder)); + return recordName; + } + + private void populate_recordName0(IndexedRecord recordName, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + recordName.put(1, null); + } else { + if (unionIndex0 == 1) { + recordName.put(1, deserializerecordName0(recordName.get(1), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1025741720_1557256887.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1025741720_1557256887.java new file mode 100644 index 000000000..e440eefcd --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1025741720_1557256887.java @@ -0,0 +1,96 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1025741720_1557256887 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_1025741720_1557256887(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + Map someIntsOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } + } + record.put(0, someIntsOption0); + } else { + throw new RuntimeException(("Illegal union index for 'someInts': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1126840752_2099305627.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1126840752_2099305627.java new file mode 100644 index 000000000..44b3945ba --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1126840752_2099305627.java @@ -0,0 +1,50 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1126840752_2099305627 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1126840752_2099305627(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + record.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 1) { + throw new AvroTypeException("Found \"string\", expecting \"int\""); + } else { + throw new RuntimeException(("Illegal union index for 'someField': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1191367445_653449771.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1191367445_653449771.java new file mode 100644 index 000000000..4ed205b75 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1191367445_653449771.java @@ -0,0 +1,69 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1191367445_653449771 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_1191367445_653449771(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList someIntsOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someIntsOption0 = ((PrimitiveIntList) oldArray0); + someIntsOption0 .clear(); + } else { + someIntsOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1373882843_1971822364(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + record.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'someInt': "+ unionIndex0)); + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1556659421_711533897.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1556659421_711533897.java new file mode 100644 index 000000000..c00ef0d0f --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1556659421_711533897.java @@ -0,0 +1,72 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1556659421_711533897 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema subRecord0; + + public record_GenericDeserializer_1556659421_711533897(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"subRecord\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"subRecord\",\"fields\":[{\"name\":\"someInt1\",\"type\":\"int\",\"doc\":\"\"},{\"name\":\"someInt2\",\"type\":\"int\",\"doc\":\"\"}]}"); + } else { + if (unionIndex0 == 1) { + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex0)); + } + } + return record; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord0); + } + subRecord.put(0, (decoder.readInt())); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + subRecord.put(1, (decoder.readInt())); + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1557256887_1025741720.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1557256887_1025741720.java new file mode 100644 index 000000000..c9ecf507c --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1557256887_1025741720.java @@ -0,0 +1,81 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1557256887_1025741720 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsMapSchema0; + private final Schema someIntsMapValueSchema0; + + public record_GenericDeserializer_1557256887_1025741720(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsMapSchema0 = someInts0 .getTypes().get(1); + this.someIntsMapValueSchema0 = someIntsMapSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map someInts1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } + } + record.put(0, someInts1); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1557256887_753570467.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1557256887_753570467.java new file mode 100644 index 000000000..a034b7652 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1557256887_753570467.java @@ -0,0 +1,79 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1557256887_753570467 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsMapSchema0; + + public record_GenericDeserializer_1557256887_753570467(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsMapSchema0 = someInts0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map someInts1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } + } + record.put(0, someInts1); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1672473580_1971822364.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1672473580_1971822364.java new file mode 100644 index 000000000..09cd58ed8 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1672473580_1971822364.java @@ -0,0 +1,50 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1672473580_1971822364 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1672473580_1971822364(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}"); + } else { + if (unionIndex0 == 1) { + return deserializerecord0((reuse), (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1971822364_1373882843.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1971822364_1373882843.java new file mode 100644 index 000000000..7d59e4519 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_1971822364_1373882843.java @@ -0,0 +1,42 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1971822364_1373882843 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInt0; + + public record_GenericDeserializer_1971822364_1373882843(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInt0 = readerSchema.getField("someInt").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_653449771_1191367445.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_653449771_1191367445.java new file mode 100644 index 000000000..0ba8d37e5 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_653449771_1191367445.java @@ -0,0 +1,61 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_653449771_1191367445 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsArraySchema0; + + public record_GenericDeserializer_653449771_1191367445(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsArraySchema0 = someInts0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + PrimitiveIntList someInts1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someInts1 = ((PrimitiveIntList) oldArray0); + someInts1 .clear(); + } else { + someInts1 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsArraySchema0; + private final Schema someIntsArrayElemSchema0; + + public record_GenericDeserializer_653449771_813379571(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsArraySchema0 = someInts0 .getTypes().get(1); + this.someIntsArrayElemSchema0 = someIntsArraySchema0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List someInts1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof List) { + someInts1 = ((List) oldArray0); + someInts1 .clear(); + } else { + someInts1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), someIntsArraySchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema subRecord0; + private final Schema subRecordRecordSchema0; + + public record_GenericDeserializer_711533897_1556659421(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + this.subRecordRecordSchema0 = subRecord0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); + return record; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecordRecordSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecordRecordSchema0); + } + subRecord.put(0, (decoder.readInt())); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + subRecord.put(1, (decoder.readInt())); + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_753570467_1557256887.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_753570467_1557256887.java new file mode 100644 index 000000000..175afef9b --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_753570467_1557256887.java @@ -0,0 +1,87 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_753570467_1557256887 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_753570467_1557256887(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + Map someIntsOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } + } + record.put(0, someIntsOption0); + } else { + throw new RuntimeException(("Illegal union index for 'someInts': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_813379571_653449771.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_813379571_653449771.java new file mode 100644 index 000000000..c2e97a298 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_8/record_GenericDeserializer_813379571_653449771.java @@ -0,0 +1,83 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_813379571_653449771 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_813379571_653449771(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList someIntsOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someIntsOption0 = ((PrimitiveIntList) oldArray0); + someIntsOption0 .clear(); + } else { + someIntsOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + + public testRecord_GenericDeserializer_1146484089_1256982207(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(3); + tempEnumMapping0 .put(new Integer(0), new Integer(0)); + tempEnumMapping0 .put(new Integer(1), new Integer(1)); + tempEnumMapping0 .put(new Integer(2), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.testEnum: No match for C")); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializetestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializetestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord testRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + testRecord = ((IndexedRecord)(reuse)); + } else { + testRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + testRecord.put(0, enumValue0); + return testRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/Array_of_BOOLEAN_GenericSerializer_869749973.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/Array_of_BOOLEAN_GenericSerializer_869749973.java new file mode 100644 index 000000000..0c530e129 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/Array_of_BOOLEAN_GenericSerializer_869749973.java @@ -0,0 +1,41 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.io.Encoder; + +public class Array_of_BOOLEAN_GenericSerializer_869749973 + implements FastSerializer> +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveBooleanList) { + PrimitiveBooleanList primitiveList0 = ((PrimitiveBooleanList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveDoubleList) { + PrimitiveDoubleList primitiveList0 = ((PrimitiveDoubleList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveFloatList) { + PrimitiveFloatList primitiveList0 = ((PrimitiveFloatList) array0); + if (primitiveList0 instanceof BufferBackedPrimitiveFloatList) { + BufferBackedPrimitiveFloatList bufferBackedPrimitiveFloatList = ((BufferBackedPrimitiveFloatList) primitiveList0); + bufferBackedPrimitiveFloatList.writeFloats((encoder)); + } else { + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList0 = ((PrimitiveIntList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveLongList) { + PrimitiveLongList primitiveList0 = ((PrimitiveLongList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (int counter0 = 0; (counter0 ) data).get(counter0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/Array_of_record_GenericSerializer_477614132.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/Array_of_record_GenericSerializer_477614132.java new file mode 100644 index 000000000..f1fb02d4b --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/Array_of_record_GenericSerializer_477614132.java @@ -0,0 +1,53 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Array_of_record_GenericSerializer_477614132 + implements FastSerializer> +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (int counter0 = 0; (counter0 ) data).get(counter0); + serializeRecord0(record0, (encoder), (customization)); + } + } + (encoder).writeArrayEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java new file mode 100644 index 000000000..cf928b2c1 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java @@ -0,0 +1,4527 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(1))); + (encoder).writeInt(((Integer) data.get(2))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(3))); + (encoder).writeInt(((Integer) data.get(4))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(5))); + (encoder).writeInt(((Integer) data.get(6))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(7))); + (encoder).writeInt(((Integer) data.get(8))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(9))); + (encoder).writeInt(((Integer) data.get(10))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(11))); + (encoder).writeInt(((Integer) data.get(12))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(13))); + (encoder).writeInt(((Integer) data.get(14))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(15))); + (encoder).writeInt(((Integer) data.get(16))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(17))); + (encoder).writeInt(((Integer) data.get(18))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(19))); + (encoder).writeInt(((Integer) data.get(20))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(21))); + (encoder).writeInt(((Integer) data.get(22))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(23))); + (encoder).writeInt(((Integer) data.get(24))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(25))); + (encoder).writeInt(((Integer) data.get(26))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(27))); + (encoder).writeInt(((Integer) data.get(28))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(29))); + (encoder).writeInt(((Integer) data.get(30))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(31))); + (encoder).writeInt(((Integer) data.get(32))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(33))); + (encoder).writeInt(((Integer) data.get(34))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(35))); + (encoder).writeInt(((Integer) data.get(36))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(37))); + (encoder).writeInt(((Integer) data.get(38))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(39))); + (encoder).writeInt(((Integer) data.get(40))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(41))); + (encoder).writeInt(((Integer) data.get(42))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(43))); + (encoder).writeInt(((Integer) data.get(44))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(45))); + (encoder).writeInt(((Integer) data.get(46))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(47))); + (encoder).writeInt(((Integer) data.get(48))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(49))); + (encoder).writeInt(((Integer) data.get(50))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(51))); + (encoder).writeInt(((Integer) data.get(52))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(53))); + (encoder).writeInt(((Integer) data.get(54))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(55))); + (encoder).writeInt(((Integer) data.get(56))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(57))); + (encoder).writeInt(((Integer) data.get(58))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(59))); + (encoder).writeInt(((Integer) data.get(60))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(61))); + (encoder).writeInt(((Integer) data.get(62))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(63))); + (encoder).writeInt(((Integer) data.get(64))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(65))); + (encoder).writeInt(((Integer) data.get(66))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(67))); + (encoder).writeInt(((Integer) data.get(68))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(69))); + (encoder).writeInt(((Integer) data.get(70))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(71))); + (encoder).writeInt(((Integer) data.get(72))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(73))); + (encoder).writeInt(((Integer) data.get(74))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(75))); + (encoder).writeInt(((Integer) data.get(76))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(77))); + (encoder).writeInt(((Integer) data.get(78))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(79))); + (encoder).writeInt(((Integer) data.get(80))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(81))); + (encoder).writeInt(((Integer) data.get(82))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(83))); + (encoder).writeInt(((Integer) data.get(84))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(85))); + (encoder).writeInt(((Integer) data.get(86))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(87))); + (encoder).writeInt(((Integer) data.get(88))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(89))); + (encoder).writeInt(((Integer) data.get(90))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(91))); + (encoder).writeInt(((Integer) data.get(92))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(93))); + (encoder).writeInt(((Integer) data.get(94))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(95))); + (encoder).writeInt(((Integer) data.get(96))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(97))); + (encoder).writeInt(((Integer) data.get(98))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(99))); + (encoder).writeInt(((Integer) data.get(100))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(101))); + (encoder).writeInt(((Integer) data.get(102))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(103))); + (encoder).writeInt(((Integer) data.get(104))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(105))); + (encoder).writeInt(((Integer) data.get(106))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(107))); + (encoder).writeInt(((Integer) data.get(108))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(109))); + (encoder).writeInt(((Integer) data.get(110))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(111))); + (encoder).writeInt(((Integer) data.get(112))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(113))); + (encoder).writeInt(((Integer) data.get(114))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(115))); + (encoder).writeInt(((Integer) data.get(116))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(117))); + (encoder).writeInt(((Integer) data.get(118))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(119))); + (encoder).writeInt(((Integer) data.get(120))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(121))); + (encoder).writeInt(((Integer) data.get(122))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(123))); + (encoder).writeInt(((Integer) data.get(124))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(125))); + (encoder).writeInt(((Integer) data.get(126))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(127))); + (encoder).writeInt(((Integer) data.get(128))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(129))); + (encoder).writeInt(((Integer) data.get(130))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(131))); + (encoder).writeInt(((Integer) data.get(132))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(133))); + (encoder).writeInt(((Integer) data.get(134))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(135))); + (encoder).writeInt(((Integer) data.get(136))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(137))); + (encoder).writeInt(((Integer) data.get(138))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(139))); + (encoder).writeInt(((Integer) data.get(140))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(141))); + (encoder).writeInt(((Integer) data.get(142))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(143))); + (encoder).writeInt(((Integer) data.get(144))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(145))); + (encoder).writeInt(((Integer) data.get(146))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(147))); + (encoder).writeInt(((Integer) data.get(148))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(149))); + (encoder).writeInt(((Integer) data.get(150))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(151))); + (encoder).writeInt(((Integer) data.get(152))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(153))); + (encoder).writeInt(((Integer) data.get(154))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(155))); + (encoder).writeInt(((Integer) data.get(156))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(157))); + (encoder).writeInt(((Integer) data.get(158))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(159))); + (encoder).writeInt(((Integer) data.get(160))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(161))); + (encoder).writeInt(((Integer) data.get(162))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(163))); + (encoder).writeInt(((Integer) data.get(164))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(165))); + (encoder).writeInt(((Integer) data.get(166))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(167))); + (encoder).writeInt(((Integer) data.get(168))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(169))); + (encoder).writeInt(((Integer) data.get(170))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(171))); + (encoder).writeInt(((Integer) data.get(172))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(173))); + (encoder).writeInt(((Integer) data.get(174))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(175))); + (encoder).writeInt(((Integer) data.get(176))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(177))); + (encoder).writeInt(((Integer) data.get(178))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(179))); + (encoder).writeInt(((Integer) data.get(180))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(181))); + (encoder).writeInt(((Integer) data.get(182))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(183))); + (encoder).writeInt(((Integer) data.get(184))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(185))); + (encoder).writeInt(((Integer) data.get(186))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(187))); + (encoder).writeInt(((Integer) data.get(188))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(189))); + (encoder).writeInt(((Integer) data.get(190))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(191))); + (encoder).writeInt(((Integer) data.get(192))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(193))); + (encoder).writeInt(((Integer) data.get(194))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(195))); + (encoder).writeInt(((Integer) data.get(196))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(197))); + (encoder).writeInt(((Integer) data.get(198))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(199))); + (encoder).writeInt(((Integer) data.get(200))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(201))); + (encoder).writeInt(((Integer) data.get(202))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(203))); + (encoder).writeInt(((Integer) data.get(204))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(205))); + (encoder).writeInt(((Integer) data.get(206))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(207))); + (encoder).writeInt(((Integer) data.get(208))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(209))); + (encoder).writeInt(((Integer) data.get(210))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(211))); + (encoder).writeInt(((Integer) data.get(212))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(213))); + (encoder).writeInt(((Integer) data.get(214))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(215))); + (encoder).writeInt(((Integer) data.get(216))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(217))); + (encoder).writeInt(((Integer) data.get(218))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(219))); + (encoder).writeInt(((Integer) data.get(220))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(221))); + (encoder).writeInt(((Integer) data.get(222))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(223))); + (encoder).writeInt(((Integer) data.get(224))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(225))); + (encoder).writeInt(((Integer) data.get(226))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(227))); + (encoder).writeInt(((Integer) data.get(228))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(229))); + (encoder).writeInt(((Integer) data.get(230))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(231))); + (encoder).writeInt(((Integer) data.get(232))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(233))); + (encoder).writeInt(((Integer) data.get(234))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(235))); + (encoder).writeInt(((Integer) data.get(236))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(237))); + (encoder).writeInt(((Integer) data.get(238))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(239))); + (encoder).writeInt(((Integer) data.get(240))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(241))); + (encoder).writeInt(((Integer) data.get(242))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(243))); + (encoder).writeInt(((Integer) data.get(244))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(245))); + (encoder).writeInt(((Integer) data.get(246))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(247))); + (encoder).writeInt(((Integer) data.get(248))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(249))); + (encoder).writeInt(((Integer) data.get(250))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(251))); + (encoder).writeInt(((Integer) data.get(252))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(253))); + (encoder).writeInt(((Integer) data.get(254))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(255))); + (encoder).writeInt(((Integer) data.get(256))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(257))); + (encoder).writeInt(((Integer) data.get(258))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(259))); + (encoder).writeInt(((Integer) data.get(260))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(261))); + (encoder).writeInt(((Integer) data.get(262))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(263))); + (encoder).writeInt(((Integer) data.get(264))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(265))); + (encoder).writeInt(((Integer) data.get(266))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(267))); + (encoder).writeInt(((Integer) data.get(268))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(269))); + (encoder).writeInt(((Integer) data.get(270))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(271))); + (encoder).writeInt(((Integer) data.get(272))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(273))); + (encoder).writeInt(((Integer) data.get(274))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(275))); + (encoder).writeInt(((Integer) data.get(276))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(277))); + (encoder).writeInt(((Integer) data.get(278))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(279))); + (encoder).writeInt(((Integer) data.get(280))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(281))); + (encoder).writeInt(((Integer) data.get(282))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(283))); + (encoder).writeInt(((Integer) data.get(284))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(285))); + (encoder).writeInt(((Integer) data.get(286))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(287))); + (encoder).writeInt(((Integer) data.get(288))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(289))); + (encoder).writeInt(((Integer) data.get(290))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(291))); + (encoder).writeInt(((Integer) data.get(292))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(293))); + (encoder).writeInt(((Integer) data.get(294))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(295))); + (encoder).writeInt(((Integer) data.get(296))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(297))); + (encoder).writeInt(((Integer) data.get(298))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(299))); + (encoder).writeInt(((Integer) data.get(300))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(301))); + (encoder).writeInt(((Integer) data.get(302))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(303))); + (encoder).writeInt(((Integer) data.get(304))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(305))); + (encoder).writeInt(((Integer) data.get(306))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(307))); + (encoder).writeInt(((Integer) data.get(308))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(309))); + (encoder).writeInt(((Integer) data.get(310))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(311))); + (encoder).writeInt(((Integer) data.get(312))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(313))); + (encoder).writeInt(((Integer) data.get(314))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(315))); + (encoder).writeInt(((Integer) data.get(316))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(317))); + (encoder).writeInt(((Integer) data.get(318))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(319))); + (encoder).writeInt(((Integer) data.get(320))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(321))); + (encoder).writeInt(((Integer) data.get(322))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(323))); + (encoder).writeInt(((Integer) data.get(324))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(325))); + (encoder).writeInt(((Integer) data.get(326))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(327))); + (encoder).writeInt(((Integer) data.get(328))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(329))); + (encoder).writeInt(((Integer) data.get(330))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(331))); + (encoder).writeInt(((Integer) data.get(332))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(333))); + (encoder).writeInt(((Integer) data.get(334))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(335))); + (encoder).writeInt(((Integer) data.get(336))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(337))); + (encoder).writeInt(((Integer) data.get(338))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(339))); + (encoder).writeInt(((Integer) data.get(340))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(341))); + (encoder).writeInt(((Integer) data.get(342))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(343))); + (encoder).writeInt(((Integer) data.get(344))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(345))); + (encoder).writeInt(((Integer) data.get(346))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(347))); + (encoder).writeInt(((Integer) data.get(348))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(349))); + (encoder).writeInt(((Integer) data.get(350))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(351))); + (encoder).writeInt(((Integer) data.get(352))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(353))); + (encoder).writeInt(((Integer) data.get(354))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(355))); + (encoder).writeInt(((Integer) data.get(356))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(357))); + (encoder).writeInt(((Integer) data.get(358))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(359))); + (encoder).writeInt(((Integer) data.get(360))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(361))); + (encoder).writeInt(((Integer) data.get(362))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(363))); + (encoder).writeInt(((Integer) data.get(364))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(365))); + (encoder).writeInt(((Integer) data.get(366))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(367))); + (encoder).writeInt(((Integer) data.get(368))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(369))); + (encoder).writeInt(((Integer) data.get(370))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(371))); + (encoder).writeInt(((Integer) data.get(372))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(373))); + (encoder).writeInt(((Integer) data.get(374))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(375))); + (encoder).writeInt(((Integer) data.get(376))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(377))); + (encoder).writeInt(((Integer) data.get(378))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(379))); + (encoder).writeInt(((Integer) data.get(380))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(381))); + (encoder).writeInt(((Integer) data.get(382))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(383))); + (encoder).writeInt(((Integer) data.get(384))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(385))); + (encoder).writeInt(((Integer) data.get(386))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(387))); + (encoder).writeInt(((Integer) data.get(388))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(389))); + (encoder).writeInt(((Integer) data.get(390))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(391))); + (encoder).writeInt(((Integer) data.get(392))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(393))); + (encoder).writeInt(((Integer) data.get(394))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(395))); + (encoder).writeInt(((Integer) data.get(396))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(397))); + (encoder).writeInt(((Integer) data.get(398))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(399))); + (encoder).writeInt(((Integer) data.get(400))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(401))); + (encoder).writeInt(((Integer) data.get(402))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(403))); + (encoder).writeInt(((Integer) data.get(404))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(405))); + (encoder).writeInt(((Integer) data.get(406))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(407))); + (encoder).writeInt(((Integer) data.get(408))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(409))); + (encoder).writeInt(((Integer) data.get(410))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(411))); + (encoder).writeInt(((Integer) data.get(412))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(413))); + (encoder).writeInt(((Integer) data.get(414))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(415))); + (encoder).writeInt(((Integer) data.get(416))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(417))); + (encoder).writeInt(((Integer) data.get(418))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(419))); + (encoder).writeInt(((Integer) data.get(420))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(421))); + (encoder).writeInt(((Integer) data.get(422))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(423))); + (encoder).writeInt(((Integer) data.get(424))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(425))); + (encoder).writeInt(((Integer) data.get(426))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(427))); + (encoder).writeInt(((Integer) data.get(428))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(429))); + (encoder).writeInt(((Integer) data.get(430))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(431))); + (encoder).writeInt(((Integer) data.get(432))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(433))); + (encoder).writeInt(((Integer) data.get(434))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(435))); + (encoder).writeInt(((Integer) data.get(436))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(437))); + (encoder).writeInt(((Integer) data.get(438))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(439))); + (encoder).writeInt(((Integer) data.get(440))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(441))); + (encoder).writeInt(((Integer) data.get(442))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(443))); + (encoder).writeInt(((Integer) data.get(444))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(445))); + (encoder).writeInt(((Integer) data.get(446))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(447))); + (encoder).writeInt(((Integer) data.get(448))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(449))); + (encoder).writeInt(((Integer) data.get(450))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(451))); + (encoder).writeInt(((Integer) data.get(452))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(453))); + (encoder).writeInt(((Integer) data.get(454))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(455))); + (encoder).writeInt(((Integer) data.get(456))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(457))); + (encoder).writeInt(((Integer) data.get(458))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(459))); + (encoder).writeInt(((Integer) data.get(460))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(461))); + (encoder).writeInt(((Integer) data.get(462))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(463))); + (encoder).writeInt(((Integer) data.get(464))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(465))); + (encoder).writeInt(((Integer) data.get(466))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(467))); + (encoder).writeInt(((Integer) data.get(468))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(469))); + (encoder).writeInt(((Integer) data.get(470))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(471))); + (encoder).writeInt(((Integer) data.get(472))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(473))); + (encoder).writeInt(((Integer) data.get(474))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(475))); + (encoder).writeInt(((Integer) data.get(476))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(477))); + (encoder).writeInt(((Integer) data.get(478))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(479))); + (encoder).writeInt(((Integer) data.get(480))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(481))); + (encoder).writeInt(((Integer) data.get(482))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(483))); + (encoder).writeInt(((Integer) data.get(484))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(485))); + (encoder).writeInt(((Integer) data.get(486))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(487))); + (encoder).writeInt(((Integer) data.get(488))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(489))); + (encoder).writeInt(((Integer) data.get(490))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(491))); + (encoder).writeInt(((Integer) data.get(492))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(493))); + (encoder).writeInt(((Integer) data.get(494))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(495))); + (encoder).writeInt(((Integer) data.get(496))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(497))); + (encoder).writeInt(((Integer) data.get(498))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(499))); + (encoder).writeInt(((Integer) data.get(500))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(501))); + (encoder).writeInt(((Integer) data.get(502))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(503))); + (encoder).writeInt(((Integer) data.get(504))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(505))); + (encoder).writeInt(((Integer) data.get(506))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(507))); + (encoder).writeInt(((Integer) data.get(508))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(509))); + (encoder).writeInt(((Integer) data.get(510))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(511))); + (encoder).writeInt(((Integer) data.get(512))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(513))); + (encoder).writeInt(((Integer) data.get(514))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(515))); + (encoder).writeInt(((Integer) data.get(516))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(517))); + (encoder).writeInt(((Integer) data.get(518))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(519))); + (encoder).writeInt(((Integer) data.get(520))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(521))); + (encoder).writeInt(((Integer) data.get(522))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(523))); + (encoder).writeInt(((Integer) data.get(524))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(525))); + (encoder).writeInt(((Integer) data.get(526))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(527))); + (encoder).writeInt(((Integer) data.get(528))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(529))); + (encoder).writeInt(((Integer) data.get(530))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(531))); + (encoder).writeInt(((Integer) data.get(532))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(533))); + (encoder).writeInt(((Integer) data.get(534))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(535))); + (encoder).writeInt(((Integer) data.get(536))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(537))); + (encoder).writeInt(((Integer) data.get(538))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(539))); + (encoder).writeInt(((Integer) data.get(540))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(541))); + (encoder).writeInt(((Integer) data.get(542))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(543))); + (encoder).writeInt(((Integer) data.get(544))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(545))); + (encoder).writeInt(((Integer) data.get(546))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(547))); + (encoder).writeInt(((Integer) data.get(548))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(549))); + (encoder).writeInt(((Integer) data.get(550))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(551))); + (encoder).writeInt(((Integer) data.get(552))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(553))); + (encoder).writeInt(((Integer) data.get(554))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(555))); + (encoder).writeInt(((Integer) data.get(556))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(557))); + (encoder).writeInt(((Integer) data.get(558))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(559))); + (encoder).writeInt(((Integer) data.get(560))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(561))); + (encoder).writeInt(((Integer) data.get(562))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(563))); + (encoder).writeInt(((Integer) data.get(564))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(565))); + (encoder).writeInt(((Integer) data.get(566))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(567))); + (encoder).writeInt(((Integer) data.get(568))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(569))); + (encoder).writeInt(((Integer) data.get(570))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(571))); + (encoder).writeInt(((Integer) data.get(572))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(573))); + (encoder).writeInt(((Integer) data.get(574))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(575))); + (encoder).writeInt(((Integer) data.get(576))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(577))); + (encoder).writeInt(((Integer) data.get(578))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(579))); + (encoder).writeInt(((Integer) data.get(580))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(581))); + (encoder).writeInt(((Integer) data.get(582))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(583))); + (encoder).writeInt(((Integer) data.get(584))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(585))); + (encoder).writeInt(((Integer) data.get(586))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(587))); + (encoder).writeInt(((Integer) data.get(588))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(589))); + (encoder).writeInt(((Integer) data.get(590))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(591))); + (encoder).writeInt(((Integer) data.get(592))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(593))); + (encoder).writeInt(((Integer) data.get(594))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(595))); + (encoder).writeInt(((Integer) data.get(596))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(597))); + (encoder).writeInt(((Integer) data.get(598))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(599))); + (encoder).writeInt(((Integer) data.get(600))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(601))); + (encoder).writeInt(((Integer) data.get(602))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(603))); + (encoder).writeInt(((Integer) data.get(604))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(605))); + (encoder).writeInt(((Integer) data.get(606))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(607))); + (encoder).writeInt(((Integer) data.get(608))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(609))); + (encoder).writeInt(((Integer) data.get(610))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(611))); + (encoder).writeInt(((Integer) data.get(612))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(613))); + (encoder).writeInt(((Integer) data.get(614))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(615))); + (encoder).writeInt(((Integer) data.get(616))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(617))); + (encoder).writeInt(((Integer) data.get(618))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(619))); + (encoder).writeInt(((Integer) data.get(620))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(621))); + (encoder).writeInt(((Integer) data.get(622))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(623))); + (encoder).writeInt(((Integer) data.get(624))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(625))); + (encoder).writeInt(((Integer) data.get(626))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(627))); + (encoder).writeInt(((Integer) data.get(628))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(629))); + (encoder).writeInt(((Integer) data.get(630))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(631))); + (encoder).writeInt(((Integer) data.get(632))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(633))); + (encoder).writeInt(((Integer) data.get(634))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(635))); + (encoder).writeInt(((Integer) data.get(636))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(637))); + (encoder).writeInt(((Integer) data.get(638))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(639))); + (encoder).writeInt(((Integer) data.get(640))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(641))); + (encoder).writeInt(((Integer) data.get(642))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(643))); + (encoder).writeInt(((Integer) data.get(644))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(645))); + (encoder).writeInt(((Integer) data.get(646))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(647))); + (encoder).writeInt(((Integer) data.get(648))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(649))); + (encoder).writeInt(((Integer) data.get(650))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(651))); + (encoder).writeInt(((Integer) data.get(652))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(653))); + (encoder).writeInt(((Integer) data.get(654))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(655))); + (encoder).writeInt(((Integer) data.get(656))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(657))); + (encoder).writeInt(((Integer) data.get(658))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(659))); + (encoder).writeInt(((Integer) data.get(660))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(661))); + (encoder).writeInt(((Integer) data.get(662))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(663))); + (encoder).writeInt(((Integer) data.get(664))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(665))); + (encoder).writeInt(((Integer) data.get(666))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(667))); + (encoder).writeInt(((Integer) data.get(668))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(669))); + (encoder).writeInt(((Integer) data.get(670))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(671))); + (encoder).writeInt(((Integer) data.get(672))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(673))); + (encoder).writeInt(((Integer) data.get(674))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(675))); + (encoder).writeInt(((Integer) data.get(676))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(677))); + (encoder).writeInt(((Integer) data.get(678))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(679))); + (encoder).writeInt(((Integer) data.get(680))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(681))); + (encoder).writeInt(((Integer) data.get(682))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(683))); + (encoder).writeInt(((Integer) data.get(684))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(685))); + (encoder).writeInt(((Integer) data.get(686))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(687))); + (encoder).writeInt(((Integer) data.get(688))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(689))); + (encoder).writeInt(((Integer) data.get(690))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(691))); + (encoder).writeInt(((Integer) data.get(692))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(693))); + (encoder).writeInt(((Integer) data.get(694))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(695))); + (encoder).writeInt(((Integer) data.get(696))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(697))); + (encoder).writeInt(((Integer) data.get(698))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(699))); + (encoder).writeInt(((Integer) data.get(700))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(701))); + (encoder).writeInt(((Integer) data.get(702))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(703))); + (encoder).writeInt(((Integer) data.get(704))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(705))); + (encoder).writeInt(((Integer) data.get(706))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(707))); + (encoder).writeInt(((Integer) data.get(708))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(709))); + (encoder).writeInt(((Integer) data.get(710))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(711))); + (encoder).writeInt(((Integer) data.get(712))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(713))); + (encoder).writeInt(((Integer) data.get(714))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(715))); + (encoder).writeInt(((Integer) data.get(716))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(717))); + (encoder).writeInt(((Integer) data.get(718))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(719))); + (encoder).writeInt(((Integer) data.get(720))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(721))); + (encoder).writeInt(((Integer) data.get(722))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(723))); + (encoder).writeInt(((Integer) data.get(724))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(725))); + (encoder).writeInt(((Integer) data.get(726))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(727))); + (encoder).writeInt(((Integer) data.get(728))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(729))); + (encoder).writeInt(((Integer) data.get(730))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(731))); + (encoder).writeInt(((Integer) data.get(732))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(733))); + (encoder).writeInt(((Integer) data.get(734))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(735))); + (encoder).writeInt(((Integer) data.get(736))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(737))); + (encoder).writeInt(((Integer) data.get(738))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(739))); + (encoder).writeInt(((Integer) data.get(740))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(741))); + (encoder).writeInt(((Integer) data.get(742))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(743))); + (encoder).writeInt(((Integer) data.get(744))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(745))); + (encoder).writeInt(((Integer) data.get(746))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(747))); + (encoder).writeInt(((Integer) data.get(748))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(749))); + (encoder).writeInt(((Integer) data.get(750))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(751))); + (encoder).writeInt(((Integer) data.get(752))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(753))); + (encoder).writeInt(((Integer) data.get(754))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(755))); + (encoder).writeInt(((Integer) data.get(756))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(757))); + (encoder).writeInt(((Integer) data.get(758))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(759))); + (encoder).writeInt(((Integer) data.get(760))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(761))); + (encoder).writeInt(((Integer) data.get(762))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(763))); + (encoder).writeInt(((Integer) data.get(764))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(765))); + (encoder).writeInt(((Integer) data.get(766))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(767))); + (encoder).writeInt(((Integer) data.get(768))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(769))); + (encoder).writeInt(((Integer) data.get(770))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(771))); + (encoder).writeInt(((Integer) data.get(772))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(773))); + (encoder).writeInt(((Integer) data.get(774))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(775))); + (encoder).writeInt(((Integer) data.get(776))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(777))); + (encoder).writeInt(((Integer) data.get(778))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(779))); + (encoder).writeInt(((Integer) data.get(780))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(781))); + (encoder).writeInt(((Integer) data.get(782))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(783))); + (encoder).writeInt(((Integer) data.get(784))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(785))); + (encoder).writeInt(((Integer) data.get(786))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(787))); + (encoder).writeInt(((Integer) data.get(788))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(789))); + (encoder).writeInt(((Integer) data.get(790))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(791))); + (encoder).writeInt(((Integer) data.get(792))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(793))); + (encoder).writeInt(((Integer) data.get(794))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(795))); + (encoder).writeInt(((Integer) data.get(796))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(797))); + (encoder).writeInt(((Integer) data.get(798))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(799))); + (encoder).writeInt(((Integer) data.get(800))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(801))); + (encoder).writeInt(((Integer) data.get(802))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(803))); + (encoder).writeInt(((Integer) data.get(804))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(805))); + (encoder).writeInt(((Integer) data.get(806))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(807))); + (encoder).writeInt(((Integer) data.get(808))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(809))); + (encoder).writeInt(((Integer) data.get(810))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(811))); + (encoder).writeInt(((Integer) data.get(812))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(813))); + (encoder).writeInt(((Integer) data.get(814))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(815))); + (encoder).writeInt(((Integer) data.get(816))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(817))); + (encoder).writeInt(((Integer) data.get(818))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(819))); + (encoder).writeInt(((Integer) data.get(820))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(821))); + (encoder).writeInt(((Integer) data.get(822))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(823))); + (encoder).writeInt(((Integer) data.get(824))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(825))); + (encoder).writeInt(((Integer) data.get(826))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(827))); + (encoder).writeInt(((Integer) data.get(828))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(829))); + (encoder).writeInt(((Integer) data.get(830))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(831))); + (encoder).writeInt(((Integer) data.get(832))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(833))); + (encoder).writeInt(((Integer) data.get(834))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(835))); + (encoder).writeInt(((Integer) data.get(836))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(837))); + (encoder).writeInt(((Integer) data.get(838))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(839))); + (encoder).writeInt(((Integer) data.get(840))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(841))); + (encoder).writeInt(((Integer) data.get(842))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(843))); + (encoder).writeInt(((Integer) data.get(844))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(845))); + (encoder).writeInt(((Integer) data.get(846))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(847))); + (encoder).writeInt(((Integer) data.get(848))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(849))); + (encoder).writeInt(((Integer) data.get(850))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(851))); + (encoder).writeInt(((Integer) data.get(852))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(853))); + (encoder).writeInt(((Integer) data.get(854))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(855))); + (encoder).writeInt(((Integer) data.get(856))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(857))); + (encoder).writeInt(((Integer) data.get(858))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(859))); + (encoder).writeInt(((Integer) data.get(860))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(861))); + (encoder).writeInt(((Integer) data.get(862))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(863))); + (encoder).writeInt(((Integer) data.get(864))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(865))); + (encoder).writeInt(((Integer) data.get(866))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(867))); + (encoder).writeInt(((Integer) data.get(868))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(869))); + (encoder).writeInt(((Integer) data.get(870))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(871))); + (encoder).writeInt(((Integer) data.get(872))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(873))); + (encoder).writeInt(((Integer) data.get(874))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(875))); + (encoder).writeInt(((Integer) data.get(876))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(877))); + (encoder).writeInt(((Integer) data.get(878))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(879))); + (encoder).writeInt(((Integer) data.get(880))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(881))); + (encoder).writeInt(((Integer) data.get(882))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(883))); + (encoder).writeInt(((Integer) data.get(884))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(885))); + (encoder).writeInt(((Integer) data.get(886))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(887))); + (encoder).writeInt(((Integer) data.get(888))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(889))); + (encoder).writeInt(((Integer) data.get(890))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(891))); + (encoder).writeInt(((Integer) data.get(892))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(893))); + (encoder).writeInt(((Integer) data.get(894))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(895))); + (encoder).writeInt(((Integer) data.get(896))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(897))); + (encoder).writeInt(((Integer) data.get(898))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(899))); + (encoder).writeInt(((Integer) data.get(900))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(901))); + (encoder).writeInt(((Integer) data.get(902))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(903))); + (encoder).writeInt(((Integer) data.get(904))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(905))); + (encoder).writeInt(((Integer) data.get(906))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(907))); + (encoder).writeInt(((Integer) data.get(908))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(909))); + (encoder).writeInt(((Integer) data.get(910))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(911))); + (encoder).writeInt(((Integer) data.get(912))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(913))); + (encoder).writeInt(((Integer) data.get(914))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(915))); + (encoder).writeInt(((Integer) data.get(916))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(917))); + (encoder).writeInt(((Integer) data.get(918))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(919))); + (encoder).writeInt(((Integer) data.get(920))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(921))); + (encoder).writeInt(((Integer) data.get(922))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(923))); + (encoder).writeInt(((Integer) data.get(924))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(925))); + (encoder).writeInt(((Integer) data.get(926))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(927))); + (encoder).writeInt(((Integer) data.get(928))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(929))); + (encoder).writeInt(((Integer) data.get(930))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(931))); + (encoder).writeInt(((Integer) data.get(932))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(933))); + (encoder).writeInt(((Integer) data.get(934))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(935))); + (encoder).writeInt(((Integer) data.get(936))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(937))); + (encoder).writeInt(((Integer) data.get(938))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(939))); + (encoder).writeInt(((Integer) data.get(940))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(941))); + (encoder).writeInt(((Integer) data.get(942))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(943))); + (encoder).writeInt(((Integer) data.get(944))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(945))); + (encoder).writeInt(((Integer) data.get(946))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(947))); + (encoder).writeInt(((Integer) data.get(948))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(949))); + (encoder).writeInt(((Integer) data.get(950))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(951))); + (encoder).writeInt(((Integer) data.get(952))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(953))); + (encoder).writeInt(((Integer) data.get(954))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(955))); + (encoder).writeInt(((Integer) data.get(956))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(957))); + (encoder).writeInt(((Integer) data.get(958))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(959))); + (encoder).writeInt(((Integer) data.get(960))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(961))); + (encoder).writeInt(((Integer) data.get(962))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(963))); + (encoder).writeInt(((Integer) data.get(964))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(965))); + (encoder).writeInt(((Integer) data.get(966))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(967))); + (encoder).writeInt(((Integer) data.get(968))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(969))); + (encoder).writeInt(((Integer) data.get(970))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(971))); + (encoder).writeInt(((Integer) data.get(972))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(973))); + (encoder).writeInt(((Integer) data.get(974))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(975))); + (encoder).writeInt(((Integer) data.get(976))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(977))); + (encoder).writeInt(((Integer) data.get(978))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(979))); + (encoder).writeInt(((Integer) data.get(980))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(981))); + (encoder).writeInt(((Integer) data.get(982))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(983))); + (encoder).writeInt(((Integer) data.get(984))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(985))); + (encoder).writeInt(((Integer) data.get(986))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(987))); + (encoder).writeInt(((Integer) data.get(988))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(989))); + (encoder).writeInt(((Integer) data.get(990))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(991))); + (encoder).writeInt(((Integer) data.get(992))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(993))); + (encoder).writeInt(((Integer) data.get(994))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(995))); + (encoder).writeInt(((Integer) data.get(996))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(997))); + (encoder).writeInt(((Integer) data.get(998))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(999))); + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java new file mode 100644 index 000000000..ebac3acf6 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java @@ -0,0 +1,116 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + int valueToWrite0; + Object enumValue0 = data.get(0); + if (enumValue0 instanceof Enum) { + valueToWrite0 = ((Enum) enumValue0).ordinal(); + } else { + valueToWrite0 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).toString()); + } + (encoder).writeEnum(valueToWrite0); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + GenericEnumSymbol testEnumUnion0 = ((GenericEnumSymbol) data.get(1)); + if (testEnumUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((testEnumUnion0 instanceof GenericEnumSymbol)&&"com.linkedin.avro.fastserde.generated.avro.testEnum".equals(((GenericEnumSymbol) testEnumUnion0).getSchema().getFullName())) { + (encoder).writeIndex(1); + int valueToWrite1; + Object enumValue1 = testEnumUnion0; + if (enumValue1 instanceof Enum) { + valueToWrite1 = ((Enum) enumValue1).ordinal(); + } else { + valueToWrite1 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).toString()); + } + (encoder).writeEnum(valueToWrite1); + } + } + List testEnumArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testEnumArray0 == null)||testEnumArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testEnumArray0 .size()); + for (int counter0 = 0; (counter0 testEnumUnionArray0 = ((List ) data.get(3)); + (encoder).writeArrayStart(); + if ((testEnumUnionArray0 == null)||testEnumUnionArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testEnumUnionArray0 .size()); + for (int counter1 = 0; (counter1 ) testEnumUnionArray0).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof GenericEnumSymbol)&&"com.linkedin.avro.fastserde.generated.avro.testEnum".equals(((GenericEnumSymbol) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + int valueToWrite3; + Object enumValue3 = union0; + if (enumValue3 instanceof Enum) { + valueToWrite3 = ((Enum) enumValue3).ordinal(); + } else { + valueToWrite3 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue3).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue3).toString()); + } + (encoder).writeEnum(valueToWrite3); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java new file mode 100644 index 000000000..3916cd1b8 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java @@ -0,0 +1,88 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + GenericFixed testFixedUnion0 = ((GenericFixed) data.get(1)); + if (testFixedUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((testFixedUnion0 instanceof GenericFixed)&&"com.linkedin.avro.fastserde.generated.avro.testFixed".equals(((GenericFixed) testFixedUnion0).getSchema().getFullName())) { + (encoder).writeIndex(1); + (encoder).writeFixed(((GenericFixed) testFixedUnion0).bytes()); + } + } + List testFixedArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testFixedArray0 == null)||testFixedArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testFixedArray0 .size()); + for (int counter0 = 0; (counter0 testFixedUnionArray0 = ((List ) data.get(3)); + (encoder).writeArrayStart(); + if ((testFixedUnionArray0 == null)||testFixedUnionArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testFixedUnionArray0 .size()); + for (int counter1 = 0; (counter1 ) testFixedUnionArray0).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof GenericFixed)&&"com.linkedin.avro.fastserde.generated.avro.testFixed".equals(((GenericFixed) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + (encoder).writeFixed(((GenericFixed) union0).bytes()); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java new file mode 100644 index 000000000..2d086c655 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java @@ -0,0 +1,70 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object union0 = ((Object) data.get(0)); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } else { + if (union0 instanceof CharSequence) { + (encoder).writeIndex(2); + if (((CharSequence) union0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) union0))); + } else { + (encoder).writeString(((CharSequence) union0).toString()); + } + } else { + if (union0 instanceof Integer) { + (encoder).writeIndex(3); + (encoder).writeInt(((Integer) union0)); + } + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java new file mode 100644 index 000000000..fab69e2dd --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java @@ -0,0 +1,157 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import java.nio.ByteBuffer; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Integer testIntUnion0 = ((Integer) data.get(1)); + if (testIntUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeInt(((Integer) testIntUnion0)); + } + Integer testFlippedIntUnion0 = ((Integer) data.get(2)); + if (testFlippedIntUnion0 == null) { + (encoder).writeIndex(1); + (encoder).writeNull(); + } else { + (encoder).writeIndex(0); + (encoder).writeInt(((Integer) testFlippedIntUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(3)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(3)))); + } else { + (encoder).writeString(((CharSequence) data.get(3)).toString()); + } + CharSequence testStringUnion0 = ((CharSequence) data.get(4)); + if (testStringUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testStringUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringUnion0))); + } else { + (encoder).writeString(((CharSequence) testStringUnion0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeLong(((Long) data.get(5))); + Long testLongUnion0 = ((Long) data.get(6)); + if (testLongUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeLong(((Long) testLongUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeDouble(((Double) data.get(7))); + Double testDoubleUnion0 = ((Double) data.get(8)); + if (testDoubleUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeDouble(((Double) testDoubleUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFloat(((Float) data.get(9))); + Float testFloatUnion0 = ((Float) data.get(10)); + if (testFloatUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeFloat(((Float) testFloatUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeBoolean(((Boolean) data.get(11))); + Boolean testBooleanUnion0 = ((Boolean) data.get(12)); + if (testBooleanUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeBoolean(((Boolean) testBooleanUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeBytes(((ByteBuffer) data.get(13))); + ByteBuffer testBytesUnion0 = ((ByteBuffer) data.get(14)); + if (testBytesUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeBytes(((ByteBuffer) testBytesUnion0)); + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java new file mode 100644 index 000000000..d5671a10a --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object union_field0 = ((Object) data.get(0)); + if (union_field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record1".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord10(((IndexedRecord) union_field0), (encoder), (customization)); + } else { + if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record2".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { + (encoder).writeIndex(2); + serializeRecord20(((IndexedRecord) union_field0), (encoder), (customization)); + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + } + + @SuppressWarnings("unchecked") + public void serializeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java new file mode 100644 index 000000000..73052d08b --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java @@ -0,0 +1,158 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List recordsArray0 = ((List ) data.get(0)); + (encoder).writeArrayStart(); + if ((recordsArray0 == null)||recordsArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsArray0 .size()); + for (int counter0 = 0; (counter0 ) recordsArray0).get(counter0); + serializeSubRecord0(subRecord0, (encoder), (customization)); + } + } + (encoder).writeArrayEnd(); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map recordsMap0 = ((Map ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMap0); + } + (encoder).writeMapStart(); + if ((recordsMap0 == null)||recordsMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsMap0 .size()); + for (CharSequence key0 : ((Map ) recordsMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord subRecord1 = null; + subRecord1 = ((Map ) recordsMap0).get(key0); + serializeSubRecord0(subRecord1, (encoder), (customization)); + } + } + (encoder).writeMapEnd(); + List recordsArrayUnion0 = ((List ) data.get(2)); + if (recordsArrayUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsArrayUnion0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) recordsArrayUnion0) == null)||((List ) recordsArrayUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) recordsArrayUnion0).size()); + for (int counter1 = 0; (counter1 <((List ) recordsArrayUnion0).size()); counter1 ++) { + (encoder).startItem(); + IndexedRecord union0 = null; + union0 = ((List )((List ) recordsArrayUnion0)).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map recordsMapUnion0 = ((Map ) data.get(3)); + if (recordsMapUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsMapUnion0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map ) recordsMapUnion0)); + } + (encoder).writeMapStart(); + if ((((Map ) recordsMapUnion0) == null)||((Map ) recordsMapUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map ) recordsMapUnion0).size()); + for (CharSequence key1 : ((Map )((Map ) recordsMapUnion0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + IndexedRecord union1 = null; + union1 = ((Map )((Map ) recordsMapUnion0)).get(key1); + if (union1 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java new file mode 100644 index 000000000..75bdca045 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java @@ -0,0 +1,230 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List> recordsArrayMap0 = ((List> ) data.get(0)); + (encoder).writeArrayStart(); + if ((recordsArrayMap0 == null)||recordsArrayMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsArrayMap0 .size()); + for (int counter0 = 0; (counter0 map0 = null; + map0 = ((List> ) recordsArrayMap0).get(counter0); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map0); + } + (encoder).writeMapStart(); + if ((map0 == null)||map0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(map0 .size()); + for (CharSequence key0 : ((Map ) map0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord union0 = null; + union0 = ((Map ) map0).get(key0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + (encoder).writeArrayEnd(); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map> recordsMapArray0 = ((Map> ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMapArray0); + } + (encoder).writeMapStart(); + if ((recordsMapArray0 == null)||recordsMapArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsMapArray0 .size()); + for (CharSequence key1 : ((Map> ) recordsMapArray0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + List array0 = null; + array0 = ((Map> ) recordsMapArray0).get(key1); + (encoder).writeArrayStart(); + if ((array0 == null)||array0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array0 .size()); + for (int counter1 = 0; (counter1 ) array0).get(counter1); + if (union1 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + (encoder).writeMapEnd(); + List> recordsArrayMapUnion0 = ((List> ) data.get(2)); + if (recordsArrayMapUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsArrayMapUnion0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List> ) recordsArrayMapUnion0) == null)||((List> ) recordsArrayMapUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List> ) recordsArrayMapUnion0).size()); + for (int counter2 = 0; (counter2 <((List> ) recordsArrayMapUnion0).size()); counter2 ++) { + (encoder).startItem(); + Map map1 = null; + map1 = ((List> )((List> ) recordsArrayMapUnion0)).get(counter2); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map1); + } + (encoder).writeMapStart(); + if ((map1 == null)||map1 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(map1 .size()); + for (CharSequence key2 : ((Map ) map1).keySet()) { + (encoder).startItem(); + (encoder).writeString(key2); + IndexedRecord union2 = null; + union2 = ((Map ) map1).get(key2); + if (union2 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union2 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union2).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union2), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + (encoder).writeArrayEnd(); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map> recordsMapArrayUnion0 = ((Map> ) data.get(3)); + if (recordsMapArrayUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsMapArrayUnion0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map> ) recordsMapArrayUnion0)); + } + (encoder).writeMapStart(); + if ((((Map> ) recordsMapArrayUnion0) == null)||((Map> ) recordsMapArrayUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map> ) recordsMapArrayUnion0).size()); + for (CharSequence key3 : ((Map> )((Map> ) recordsMapArrayUnion0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key3); + List array1 = null; + array1 = ((Map> )((Map> ) recordsMapArrayUnion0)).get(key3); + (encoder).writeArrayStart(); + if ((array1 == null)||array1 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array1 .size()); + for (int counter3 = 0; (counter3 ) array1).get(counter3); + if (union3 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union3 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union3).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union3), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + (encoder).writeMapEnd(); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java new file mode 100644 index 000000000..77ec06d6e --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + IndexedRecord record0 = ((IndexedRecord) data.get(0)); + if (record0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((record0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) record0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) record0), (encoder), (customization)); + } + } + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + IndexedRecord record10 = ((IndexedRecord) data.get(1)); + serializeSubRecord0(record10, (encoder), (customization)); + CharSequence field0 = ((CharSequence) data.get(2)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastSerdeEnums_GenericSerializer_957378572.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastSerdeEnums_GenericSerializer_957378572.java new file mode 100644 index 000000000..b6af90acf --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastSerdeEnums_GenericSerializer_957378572.java @@ -0,0 +1,95 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeEnums_GenericSerializer_957378572 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + int valueToWrite0; + Object enumValue0 = data.get(0); + if (enumValue0 instanceof Enum) { + valueToWrite0 = ((Enum) enumValue0).ordinal(); + } else { + valueToWrite0 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).toString()); + } + (encoder).writeEnum(valueToWrite0); + serialize_FastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List arrayOfEnums0 = ((List ) data.get(1)); + if (arrayOfEnums0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (arrayOfEnums0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) arrayOfEnums0) == null)||((List ) arrayOfEnums0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) arrayOfEnums0).size()); + for (int counter0 = 0; (counter0 <((List ) arrayOfEnums0).size()); counter0 ++) { + (encoder).startItem(); + int valueToWrite1; + Object enumValue1 = ((List ) arrayOfEnums0).get(counter0); + if (enumValue1 instanceof Enum) { + valueToWrite1 = ((Enum) enumValue1).ordinal(); + } else { + valueToWrite1 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).toString()); + } + (encoder).writeEnum(valueToWrite1); + } + } + (encoder).writeArrayEnd(); + } + } + Map mapOfEnums0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfEnums0); + } + (encoder).writeMapStart(); + if ((mapOfEnums0 == null)||mapOfEnums0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfEnums0 .size()); + for (CharSequence key0 : ((Map ) mapOfEnums0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + int valueToWrite2; + Object enumValue2 = mapOfEnums0 .get(key0); + if (enumValue2 instanceof Enum) { + valueToWrite2 = ((Enum) enumValue2).ordinal(); + } else { + valueToWrite2 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue2).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue2).toString()); + } + (encoder).writeEnum(valueToWrite2); + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastSerdeFixed_GenericSerializer_504108934.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastSerdeFixed_GenericSerializer_504108934.java new file mode 100644 index 000000000..dc2c78c0a --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastSerdeFixed_GenericSerializer_504108934.java @@ -0,0 +1,74 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeFixed_GenericSerializer_504108934 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List arrayOfFixed0 = ((List ) data.get(1)); + if (arrayOfFixed0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (arrayOfFixed0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) arrayOfFixed0) == null)||((List ) arrayOfFixed0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) arrayOfFixed0).size()); + for (int counter0 = 0; (counter0 <((List ) arrayOfFixed0).size()); counter0 ++) { + (encoder).startItem(); + (encoder).writeFixed(((GenericFixed)((List ) arrayOfFixed0).get(counter0)).bytes()); + } + } + (encoder).writeArrayEnd(); + } + } + Map mapOfFixed0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfFixed0); + } + (encoder).writeMapStart(); + if ((mapOfFixed0 == null)||mapOfFixed0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfFixed0 .size()); + for (CharSequence key0 : ((Map ) mapOfFixed0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + (encoder).writeFixed(((GenericFixed) mapOfFixed0 .get(key0)).bytes()); + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java new file mode 100644 index 000000000..cb1e95fae --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java @@ -0,0 +1,97 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence testUnionString0 = ((CharSequence) data.get(1)); + if (testUnionString0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testUnionString0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testUnionString0))); + } else { + (encoder).writeString(((CharSequence) testUnionString0).toString()); + } + } + List testStringArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testStringArray0 == null)||testStringArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringArray0 .size()); + for (int counter0 = 0; (counter0 testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } + (encoder).writeMapStart(); + if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringMap0 .size()); + for (CharSequence key0 : ((Map ) testStringMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) testStringMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) testStringMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java new file mode 100644 index 000000000..c79fa9ffc --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java @@ -0,0 +1,97 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_FastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence testUnionString0 = ((CharSequence) data.get(1)); + if (testUnionString0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testUnionString0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testUnionString0))); + } else { + (encoder).writeString(((CharSequence) testUnionString0).toString()); + } + } + List testStringArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testStringArray0 == null)||testStringArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringArray0 .size()); + for (int counter0 = 0; (counter0 testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } + (encoder).writeMapStart(); + if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringMap0 .size()); + for (CharSequence key0 : ((Map ) testStringMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) testStringMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) testStringMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/Map_of_UNION_GenericSerializer_2140000109.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/Map_of_UNION_GenericSerializer_2140000109.java new file mode 100644 index 000000000..993dc0561 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/Map_of_UNION_GenericSerializer_2140000109.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Map_of_UNION_GenericSerializer_2140000109 + implements FastSerializer> +{ + + + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } + (encoder).writeMapStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (CharSequence key0 : ((Map ) data).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord union0 = null; + union0 = ((Map ) data).get(key0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/Map_of_record_GenericSerializer_1677529043.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/Map_of_record_GenericSerializer_1677529043.java new file mode 100644 index 000000000..0518596bf --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/Map_of_record_GenericSerializer_1677529043.java @@ -0,0 +1,57 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Map_of_record_GenericSerializer_1677529043 + implements FastSerializer> +{ + + + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } + (encoder).writeMapStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (CharSequence key0 : ((Map ) data).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord record0 = null; + record0 = ((Map ) data).get(key0); + serializeRecord0(record0, (encoder), (customization)); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/StringableRecord_SpecificSerializer_842267318.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/StringableRecord_SpecificSerializer_842267318.java new file mode 100644 index 000000000..8a1a29640 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/StringableRecord_SpecificSerializer_842267318.java @@ -0,0 +1,159 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.File; +import java.io.IOException; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.net.URI; +import java.net.URL; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord; +import com.linkedin.avro.fastserde.generated.avro.StringableRecord; +import com.linkedin.avro.fastserde.generated.avro.StringableSubRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class StringableRecord_SpecificSerializer_842267318 + implements FastSerializer +{ + + + public void serialize(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeStringableRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((BigInteger) data.get(0)).toString()); + serialize_StringableRecord0(data, (encoder), (customization)); + serialize_StringableRecord1(data, (encoder), (customization)); + serialize_StringableRecord2(data, (encoder), (customization)); + serialize_StringableRecord3(data, (encoder), (customization)); + serialize_StringableRecord4(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((BigDecimal) data.get(1)).toString()); + (encoder).writeString(((URI) data.get(2)).toString()); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord1(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((URL) data.get(3)).toString()); + (encoder).writeString(((File) data.get(4)).toString()); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord2(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List urlArray0 = ((List ) data.get(5)); + (encoder).writeArrayStart(); + if ((urlArray0 == null)||urlArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(urlArray0 .size()); + for (int counter0 = 0; (counter0 urlMap0 = ((Map ) data.get(6)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(urlMap0); + } + (encoder).writeMapStart(); + if ((urlMap0 == null)||urlMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(urlMap0 .size()); + for (URL key0 : ((Map ) urlMap0).keySet()) { + (encoder).startItem(); + String keyString0 = key0 .toString(); + (encoder).writeString(keyString0); + (encoder).writeString(((BigInteger) urlMap0 .get(key0)).toString()); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord3(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord0 = ((StringableSubRecord) data.get(7)); + serializeStringableSubRecord0(subRecord0, (encoder), (customization)); + AnotherSubRecord subRecordWithSubRecord0 = ((AnotherSubRecord) data.get(8)); + serializeAnotherSubRecord0(subRecordWithSubRecord0, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((URI) data.get(0)).toString()); + serialize_StringableSubRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object nullStringIntUnion0 = ((Object) data.get(1)); + if (nullStringIntUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (nullStringIntUnion0 instanceof CharSequence) { + (encoder).writeIndex(1); + if (((CharSequence) nullStringIntUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) nullStringIntUnion0))); + } else { + (encoder).writeString(((CharSequence) nullStringIntUnion0).toString()); + } + } else { + if (nullStringIntUnion0 instanceof Integer) { + (encoder).writeIndex(2); + (encoder).writeInt(((Integer) nullStringIntUnion0)); + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeAnotherSubRecord0(AnotherSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord1 = ((StringableSubRecord) data.get(0)); + serializeStringableSubRecord0(subRecord1, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord4(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + String stringUnion0 = ((String) data.get(9)); + if (stringUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeString(((String) stringUnion0).toString()); + } + } + +} diff --git a/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/TestArrayOfFloats_GenericSerializer_1408566797.java b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/TestArrayOfFloats_GenericSerializer_1408566797.java new file mode 100644 index 000000000..fc107dc42 --- /dev/null +++ b/fastserde/avro-fastserde-tests18/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_8/TestArrayOfFloats_GenericSerializer_1408566797.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_8; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class TestArrayOfFloats_GenericSerializer_1408566797 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeTestArrayOfFloats0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeTestArrayOfFloats0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List array_of_float0 = ((List ) data.get(0)); + (encoder).writeArrayStart(); + if ((array_of_float0 == null)||array_of_float0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array_of_float0 .size()); + Object array0 = array_of_float0; + if (array0 instanceof PrimitiveFloatList) { + PrimitiveFloatList primitiveList0 = ((PrimitiveFloatList) array0); + if (primitiveList0 instanceof BufferBackedPrimitiveFloatList) { + BufferBackedPrimitiveFloatList bufferBackedPrimitiveFloatList = ((BufferBackedPrimitiveFloatList) primitiveList0); + bufferBackedPrimitiveFloatList.writeFloats((encoder)); + } else { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_BOOLEAN_GenericDeserializer_869749973_869749973(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveBooleanList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveBooleanList) { + array0 = ((PrimitiveBooleanList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveBooleanArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_DOUBLE_GenericDeserializer_18760307_18760307(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveDoubleList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveDoubleList) { + array0 = ((PrimitiveDoubleList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveDoubleArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_FLOAT_GenericDeserializer_1012670397_1012670397(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveFloatList array0 = null; + array0 = ((PrimitiveFloatList) BufferBackedPrimitiveFloatList.readPrimitiveFloatArray((reuse), (decoder))); + return array0; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/Array_of_INT_GenericDeserializer_1012089072_1012089072.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/Array_of_INT_GenericDeserializer_1012089072_1012089072.java new file mode 100644 index 000000000..f0c5b64fe --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/Array_of_INT_GenericDeserializer_1012089072_1012089072.java @@ -0,0 +1,43 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class Array_of_INT_GenericDeserializer_1012089072_1012089072 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Array_of_INT_GenericDeserializer_1012089072_1012089072(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveIntList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveIntList) { + array0 = ((PrimitiveIntList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_LONG_GenericDeserializer_325099267_325099267(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + PrimitiveLongList array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof PrimitiveLongList) { + array0 = ((PrimitiveLongList)(reuse)); + array0 .clear(); + } else { + array0 = new PrimitiveLongArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_TestRecord_SpecificDeserializer_1088113243_1088113243(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + if (array0 instanceof GenericArray) { + ((GenericArray) array0).reset(); + } else { + array0 .clear(); + } + } else { + array0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + if (testFixedArray0 instanceof GenericArray) { + ((GenericArray) testFixedArray0).reset(); + } else { + testFixedArray0 .clear(); + } + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + if (testFixedUnionArray0 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray0).reset(); + } else { + testFixedUnionArray0 .clear(); + } + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + if (testEnumArray0 instanceof GenericArray) { + ((GenericArray) testEnumArray0).reset(); + } else { + testEnumArray0 .clear(); + } + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + if (testEnumUnionArray0 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray0).reset(); + } else { + testEnumUnionArray0 .clear(); + } + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + if (recordsArray0 instanceof GenericArray) { + ((GenericArray) recordsArray0).reset(); + } else { + recordsArray0 .clear(); + } + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + if (recordsArrayMap0 instanceof GenericArray) { + ((GenericArray) recordsArrayMap0).reset(); + } else { + recordsArrayMap0 .clear(); + } + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + if (stringArray0 instanceof GenericArray) { + ((GenericArray) stringArray0).reset(); + } else { + stringArray0 .clear(); + } + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema arrayArrayElemSchema0; + private final Schema arrayElemOptionSchema0; + private final Schema field0; + + public Array_of_UNION_GenericDeserializer_777827233_777827233(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArrayElemSchema0 = readerSchema.getElementType(); + this.arrayElemOptionSchema0 = arrayArrayElemSchema0 .getTypes().get(1); + this.field0 = arrayElemOptionSchema0 .getField("field").schema(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + if (array0 instanceof GenericArray) { + ((GenericArray) array0).reset(); + } else { + array0 .clear(); + } + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + + public Array_of_UNION_SpecificDeserializer_1277939469_1277939469(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + if (array0 instanceof GenericArray) { + ((GenericArray) array0).reset(); + } else { + array0 .clear(); + } + } else { + array0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + if (testFixedArray0 instanceof GenericArray) { + ((GenericArray) testFixedArray0).reset(); + } else { + testFixedArray0 .clear(); + } + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + if (testFixedUnionArray0 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray0).reset(); + } else { + testFixedUnionArray0 .clear(); + } + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + if (testEnumArray0 instanceof GenericArray) { + ((GenericArray) testEnumArray0).reset(); + } else { + testEnumArray0 .clear(); + } + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + if (testEnumUnionArray0 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray0).reset(); + } else { + testEnumUnionArray0 .clear(); + } + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + if (recordsArray0 instanceof GenericArray) { + ((GenericArray) recordsArray0).reset(); + } else { + recordsArray0 .clear(); + } + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex15 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex17)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + if (recordsArrayMap0 instanceof GenericArray) { + ((GenericArray) recordsArrayMap0).reset(); + } else { + recordsArrayMap0 .clear(); + } + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex21 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex21)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex23 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex23)); + } + } + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex25 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex25 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex25 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex25)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + if (stringArray0 instanceof GenericArray) { + ((GenericArray) stringArray0).reset(); + } else { + stringArray0 .clear(); + } + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema unionOptionArrayElemSchema0; + + public Array_of_record_GenericDeserializer_1606337179_2018567528(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOptionArrayElemSchema0 = readerSchema.getElementType(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":{\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}}"); + } else { + if (unionIndex0 == 1) { + List unionOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + unionOption0 = ((List)(reuse)); + if (unionOption0 instanceof GenericArray) { + ((GenericArray) unionOption0).reset(); + } else { + unionOption0 .clear(); + } + } else { + unionOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + private final Schema arrayArrayElemSchema0; + private final Schema field0; + + public Array_of_record_GenericDeserializer_477614132_477614132(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArrayElemSchema0 = readerSchema.getElementType(); + this.field0 = arrayArrayElemSchema0 .getField("field").schema(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + if (array0 instanceof GenericArray) { + ((GenericArray) array0).reset(); + } else { + array0 .clear(); + } + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), readerSchema); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema f00; + private final Schema f10; + private final Schema f20; + private final Schema f30; + private final Schema f40; + private final Schema f50; + private final Schema f60; + private final Schema f70; + private final Schema f80; + private final Schema f90; + private final Schema f100; + private final Schema f110; + private final Schema f120; + private final Schema f130; + private final Schema f140; + private final Schema f150; + private final Schema f160; + private final Schema f170; + private final Schema f180; + private final Schema f190; + private final Schema f200; + private final Schema f210; + private final Schema f220; + private final Schema f230; + private final Schema f240; + private final Schema f250; + private final Schema f260; + private final Schema f270; + private final Schema f280; + private final Schema f290; + private final Schema f300; + private final Schema f310; + private final Schema f320; + private final Schema f330; + private final Schema f340; + private final Schema f350; + private final Schema f360; + private final Schema f370; + private final Schema f380; + private final Schema f390; + private final Schema f400; + private final Schema f410; + private final Schema f420; + private final Schema f430; + private final Schema f440; + private final Schema f450; + private final Schema f460; + private final Schema f470; + private final Schema f480; + private final Schema f490; + private final Schema f500; + private final Schema f510; + private final Schema f520; + private final Schema f530; + private final Schema f540; + private final Schema f550; + private final Schema f560; + private final Schema f570; + private final Schema f580; + private final Schema f590; + private final Schema f600; + private final Schema f610; + private final Schema f620; + private final Schema f630; + private final Schema f640; + private final Schema f650; + private final Schema f660; + private final Schema f670; + private final Schema f680; + private final Schema f690; + private final Schema f700; + private final Schema f710; + private final Schema f720; + private final Schema f730; + private final Schema f740; + private final Schema f750; + private final Schema f760; + private final Schema f770; + private final Schema f780; + private final Schema f790; + private final Schema f800; + private final Schema f810; + private final Schema f820; + private final Schema f830; + private final Schema f840; + private final Schema f850; + private final Schema f860; + private final Schema f870; + private final Schema f880; + private final Schema f890; + private final Schema f900; + private final Schema f910; + private final Schema f920; + private final Schema f930; + private final Schema f940; + private final Schema f950; + private final Schema f960; + private final Schema f970; + private final Schema f980; + private final Schema f990; + private final Schema f1000; + private final Schema f1010; + private final Schema f1020; + private final Schema f1030; + private final Schema f1040; + private final Schema f1050; + private final Schema f1060; + private final Schema f1070; + private final Schema f1080; + private final Schema f1090; + private final Schema f1100; + private final Schema f1110; + private final Schema f1120; + private final Schema f1130; + private final Schema f1140; + private final Schema f1150; + private final Schema f1160; + private final Schema f1170; + private final Schema f1180; + private final Schema f1190; + private final Schema f1200; + private final Schema f1210; + private final Schema f1220; + private final Schema f1230; + private final Schema f1240; + private final Schema f1250; + private final Schema f1260; + private final Schema f1270; + private final Schema f1280; + private final Schema f1290; + private final Schema f1300; + private final Schema f1310; + private final Schema f1320; + private final Schema f1330; + private final Schema f1340; + private final Schema f1350; + private final Schema f1360; + private final Schema f1370; + private final Schema f1380; + private final Schema f1390; + private final Schema f1400; + private final Schema f1410; + private final Schema f1420; + private final Schema f1430; + private final Schema f1440; + private final Schema f1450; + private final Schema f1460; + private final Schema f1470; + private final Schema f1480; + private final Schema f1490; + private final Schema f1500; + private final Schema f1510; + private final Schema f1520; + private final Schema f1530; + private final Schema f1540; + private final Schema f1550; + private final Schema f1560; + private final Schema f1570; + private final Schema f1580; + private final Schema f1590; + private final Schema f1600; + private final Schema f1610; + private final Schema f1620; + private final Schema f1630; + private final Schema f1640; + private final Schema f1650; + private final Schema f1660; + private final Schema f1670; + private final Schema f1680; + private final Schema f1690; + private final Schema f1700; + private final Schema f1710; + private final Schema f1720; + private final Schema f1730; + private final Schema f1740; + private final Schema f1750; + private final Schema f1760; + private final Schema f1770; + private final Schema f1780; + private final Schema f1790; + private final Schema f1800; + private final Schema f1810; + private final Schema f1820; + private final Schema f1830; + private final Schema f1840; + private final Schema f1850; + private final Schema f1860; + private final Schema f1870; + private final Schema f1880; + private final Schema f1890; + private final Schema f1900; + private final Schema f1910; + private final Schema f1920; + private final Schema f1930; + private final Schema f1940; + private final Schema f1950; + private final Schema f1960; + private final Schema f1970; + private final Schema f1980; + private final Schema f1990; + private final Schema f2000; + private final Schema f2010; + private final Schema f2020; + private final Schema f2030; + private final Schema f2040; + private final Schema f2050; + private final Schema f2060; + private final Schema f2070; + private final Schema f2080; + private final Schema f2090; + private final Schema f2100; + private final Schema f2110; + private final Schema f2120; + private final Schema f2130; + private final Schema f2140; + private final Schema f2150; + private final Schema f2160; + private final Schema f2170; + private final Schema f2180; + private final Schema f2190; + private final Schema f2200; + private final Schema f2210; + private final Schema f2220; + private final Schema f2230; + private final Schema f2240; + private final Schema f2250; + private final Schema f2260; + private final Schema f2270; + private final Schema f2280; + private final Schema f2290; + private final Schema f2300; + private final Schema f2310; + private final Schema f2320; + private final Schema f2330; + private final Schema f2340; + private final Schema f2350; + private final Schema f2360; + private final Schema f2370; + private final Schema f2380; + private final Schema f2390; + private final Schema f2400; + private final Schema f2410; + private final Schema f2420; + private final Schema f2430; + private final Schema f2440; + private final Schema f2450; + private final Schema f2460; + private final Schema f2470; + private final Schema f2480; + private final Schema f2490; + private final Schema f2500; + private final Schema f2510; + private final Schema f2520; + private final Schema f2530; + private final Schema f2540; + private final Schema f2550; + private final Schema f2560; + private final Schema f2570; + private final Schema f2580; + private final Schema f2590; + private final Schema f2600; + private final Schema f2610; + private final Schema f2620; + private final Schema f2630; + private final Schema f2640; + private final Schema f2650; + private final Schema f2660; + private final Schema f2670; + private final Schema f2680; + private final Schema f2690; + private final Schema f2700; + private final Schema f2710; + private final Schema f2720; + private final Schema f2730; + private final Schema f2740; + private final Schema f2750; + private final Schema f2760; + private final Schema f2770; + private final Schema f2780; + private final Schema f2790; + private final Schema f2800; + private final Schema f2810; + private final Schema f2820; + private final Schema f2830; + private final Schema f2840; + private final Schema f2850; + private final Schema f2860; + private final Schema f2870; + private final Schema f2880; + private final Schema f2890; + private final Schema f2900; + private final Schema f2910; + private final Schema f2920; + private final Schema f2930; + private final Schema f2940; + private final Schema f2950; + private final Schema f2960; + private final Schema f2970; + private final Schema f2980; + private final Schema f2990; + private final Schema f3000; + private final Schema f3010; + private final Schema f3020; + private final Schema f3030; + private final Schema f3040; + private final Schema f3050; + private final Schema f3060; + private final Schema f3070; + private final Schema f3080; + private final Schema f3090; + private final Schema f3100; + private final Schema f3110; + private final Schema f3120; + private final Schema f3130; + private final Schema f3140; + private final Schema f3150; + private final Schema f3160; + private final Schema f3170; + private final Schema f3180; + private final Schema f3190; + private final Schema f3200; + private final Schema f3210; + private final Schema f3220; + private final Schema f3230; + private final Schema f3240; + private final Schema f3250; + private final Schema f3260; + private final Schema f3270; + private final Schema f3280; + private final Schema f3290; + private final Schema f3300; + private final Schema f3310; + private final Schema f3320; + private final Schema f3330; + private final Schema f3340; + private final Schema f3350; + private final Schema f3360; + private final Schema f3370; + private final Schema f3380; + private final Schema f3390; + private final Schema f3400; + private final Schema f3410; + private final Schema f3420; + private final Schema f3430; + private final Schema f3440; + private final Schema f3450; + private final Schema f3460; + private final Schema f3470; + private final Schema f3480; + private final Schema f3490; + private final Schema f3500; + private final Schema f3510; + private final Schema f3520; + private final Schema f3530; + private final Schema f3540; + private final Schema f3550; + private final Schema f3560; + private final Schema f3570; + private final Schema f3580; + private final Schema f3590; + private final Schema f3600; + private final Schema f3610; + private final Schema f3620; + private final Schema f3630; + private final Schema f3640; + private final Schema f3650; + private final Schema f3660; + private final Schema f3670; + private final Schema f3680; + private final Schema f3690; + private final Schema f3700; + private final Schema f3710; + private final Schema f3720; + private final Schema f3730; + private final Schema f3740; + private final Schema f3750; + private final Schema f3760; + private final Schema f3770; + private final Schema f3780; + private final Schema f3790; + private final Schema f3800; + private final Schema f3810; + private final Schema f3820; + private final Schema f3830; + private final Schema f3840; + private final Schema f3850; + private final Schema f3860; + private final Schema f3870; + private final Schema f3880; + private final Schema f3890; + private final Schema f3900; + private final Schema f3910; + private final Schema f3920; + private final Schema f3930; + private final Schema f3940; + private final Schema f3950; + private final Schema f3960; + private final Schema f3970; + private final Schema f3980; + private final Schema f3990; + private final Schema f4000; + private final Schema f4010; + private final Schema f4020; + private final Schema f4030; + private final Schema f4040; + private final Schema f4050; + private final Schema f4060; + private final Schema f4070; + private final Schema f4080; + private final Schema f4090; + private final Schema f4100; + private final Schema f4110; + private final Schema f4120; + private final Schema f4130; + private final Schema f4140; + private final Schema f4150; + private final Schema f4160; + private final Schema f4170; + private final Schema f4180; + private final Schema f4190; + private final Schema f4200; + private final Schema f4210; + private final Schema f4220; + private final Schema f4230; + private final Schema f4240; + private final Schema f4250; + private final Schema f4260; + private final Schema f4270; + private final Schema f4280; + private final Schema f4290; + private final Schema f4300; + private final Schema f4310; + private final Schema f4320; + private final Schema f4330; + private final Schema f4340; + private final Schema f4350; + private final Schema f4360; + private final Schema f4370; + private final Schema f4380; + private final Schema f4390; + private final Schema f4400; + private final Schema f4410; + private final Schema f4420; + private final Schema f4430; + private final Schema f4440; + private final Schema f4450; + private final Schema f4460; + private final Schema f4470; + private final Schema f4480; + private final Schema f4490; + private final Schema f4500; + private final Schema f4510; + private final Schema f4520; + private final Schema f4530; + private final Schema f4540; + private final Schema f4550; + private final Schema f4560; + private final Schema f4570; + private final Schema f4580; + private final Schema f4590; + private final Schema f4600; + private final Schema f4610; + private final Schema f4620; + private final Schema f4630; + private final Schema f4640; + private final Schema f4650; + private final Schema f4660; + private final Schema f4670; + private final Schema f4680; + private final Schema f4690; + private final Schema f4700; + private final Schema f4710; + private final Schema f4720; + private final Schema f4730; + private final Schema f4740; + private final Schema f4750; + private final Schema f4760; + private final Schema f4770; + private final Schema f4780; + private final Schema f4790; + private final Schema f4800; + private final Schema f4810; + private final Schema f4820; + private final Schema f4830; + private final Schema f4840; + private final Schema f4850; + private final Schema f4860; + private final Schema f4870; + private final Schema f4880; + private final Schema f4890; + private final Schema f4900; + private final Schema f4910; + private final Schema f4920; + private final Schema f4930; + private final Schema f4940; + private final Schema f4950; + private final Schema f4960; + private final Schema f4970; + private final Schema f4980; + private final Schema f4990; + private final Schema f5000; + private final Schema f5010; + private final Schema f5020; + private final Schema f5030; + private final Schema f5040; + private final Schema f5050; + private final Schema f5060; + private final Schema f5070; + private final Schema f5080; + private final Schema f5090; + private final Schema f5100; + private final Schema f5110; + private final Schema f5120; + private final Schema f5130; + private final Schema f5140; + private final Schema f5150; + private final Schema f5160; + private final Schema f5170; + private final Schema f5180; + private final Schema f5190; + private final Schema f5200; + private final Schema f5210; + private final Schema f5220; + private final Schema f5230; + private final Schema f5240; + private final Schema f5250; + private final Schema f5260; + private final Schema f5270; + private final Schema f5280; + private final Schema f5290; + private final Schema f5300; + private final Schema f5310; + private final Schema f5320; + private final Schema f5330; + private final Schema f5340; + private final Schema f5350; + private final Schema f5360; + private final Schema f5370; + private final Schema f5380; + private final Schema f5390; + private final Schema f5400; + private final Schema f5410; + private final Schema f5420; + private final Schema f5430; + private final Schema f5440; + private final Schema f5450; + private final Schema f5460; + private final Schema f5470; + private final Schema f5480; + private final Schema f5490; + private final Schema f5500; + private final Schema f5510; + private final Schema f5520; + private final Schema f5530; + private final Schema f5540; + private final Schema f5550; + private final Schema f5560; + private final Schema f5570; + private final Schema f5580; + private final Schema f5590; + private final Schema f5600; + private final Schema f5610; + private final Schema f5620; + private final Schema f5630; + private final Schema f5640; + private final Schema f5650; + private final Schema f5660; + private final Schema f5670; + private final Schema f5680; + private final Schema f5690; + private final Schema f5700; + private final Schema f5710; + private final Schema f5720; + private final Schema f5730; + private final Schema f5740; + private final Schema f5750; + private final Schema f5760; + private final Schema f5770; + private final Schema f5780; + private final Schema f5790; + private final Schema f5800; + private final Schema f5810; + private final Schema f5820; + private final Schema f5830; + private final Schema f5840; + private final Schema f5850; + private final Schema f5860; + private final Schema f5870; + private final Schema f5880; + private final Schema f5890; + private final Schema f5900; + private final Schema f5910; + private final Schema f5920; + private final Schema f5930; + private final Schema f5940; + private final Schema f5950; + private final Schema f5960; + private final Schema f5970; + private final Schema f5980; + private final Schema f5990; + private final Schema f6000; + private final Schema f6010; + private final Schema f6020; + private final Schema f6030; + private final Schema f6040; + private final Schema f6050; + private final Schema f6060; + private final Schema f6070; + private final Schema f6080; + private final Schema f6090; + private final Schema f6100; + private final Schema f6110; + private final Schema f6120; + private final Schema f6130; + private final Schema f6140; + private final Schema f6150; + private final Schema f6160; + private final Schema f6170; + private final Schema f6180; + private final Schema f6190; + private final Schema f6200; + private final Schema f6210; + private final Schema f6220; + private final Schema f6230; + private final Schema f6240; + private final Schema f6250; + private final Schema f6260; + private final Schema f6270; + private final Schema f6280; + private final Schema f6290; + private final Schema f6300; + private final Schema f6310; + private final Schema f6320; + private final Schema f6330; + private final Schema f6340; + private final Schema f6350; + private final Schema f6360; + private final Schema f6370; + private final Schema f6380; + private final Schema f6390; + private final Schema f6400; + private final Schema f6410; + private final Schema f6420; + private final Schema f6430; + private final Schema f6440; + private final Schema f6450; + private final Schema f6460; + private final Schema f6470; + private final Schema f6480; + private final Schema f6490; + private final Schema f6500; + private final Schema f6510; + private final Schema f6520; + private final Schema f6530; + private final Schema f6540; + private final Schema f6550; + private final Schema f6560; + private final Schema f6570; + private final Schema f6580; + private final Schema f6590; + private final Schema f6600; + private final Schema f6610; + private final Schema f6620; + private final Schema f6630; + private final Schema f6640; + private final Schema f6650; + private final Schema f6660; + private final Schema f6670; + private final Schema f6680; + private final Schema f6690; + private final Schema f6700; + private final Schema f6710; + private final Schema f6720; + private final Schema f6730; + private final Schema f6740; + private final Schema f6750; + private final Schema f6760; + private final Schema f6770; + private final Schema f6780; + private final Schema f6790; + private final Schema f6800; + private final Schema f6810; + private final Schema f6820; + private final Schema f6830; + private final Schema f6840; + private final Schema f6850; + private final Schema f6860; + private final Schema f6870; + private final Schema f6880; + private final Schema f6890; + private final Schema f6900; + private final Schema f6910; + private final Schema f6920; + private final Schema f6930; + private final Schema f6940; + private final Schema f6950; + private final Schema f6960; + private final Schema f6970; + private final Schema f6980; + private final Schema f6990; + private final Schema f7000; + private final Schema f7010; + private final Schema f7020; + private final Schema f7030; + private final Schema f7040; + private final Schema f7050; + private final Schema f7060; + private final Schema f7070; + private final Schema f7080; + private final Schema f7090; + private final Schema f7100; + private final Schema f7110; + private final Schema f7120; + private final Schema f7130; + private final Schema f7140; + private final Schema f7150; + private final Schema f7160; + private final Schema f7170; + private final Schema f7180; + private final Schema f7190; + private final Schema f7200; + private final Schema f7210; + private final Schema f7220; + private final Schema f7230; + private final Schema f7240; + private final Schema f7250; + private final Schema f7260; + private final Schema f7270; + private final Schema f7280; + private final Schema f7290; + private final Schema f7300; + private final Schema f7310; + private final Schema f7320; + private final Schema f7330; + private final Schema f7340; + private final Schema f7350; + private final Schema f7360; + private final Schema f7370; + private final Schema f7380; + private final Schema f7390; + private final Schema f7400; + private final Schema f7410; + private final Schema f7420; + private final Schema f7430; + private final Schema f7440; + private final Schema f7450; + private final Schema f7460; + private final Schema f7470; + private final Schema f7480; + private final Schema f7490; + private final Schema f7500; + private final Schema f7510; + private final Schema f7520; + private final Schema f7530; + private final Schema f7540; + private final Schema f7550; + private final Schema f7560; + private final Schema f7570; + private final Schema f7580; + private final Schema f7590; + private final Schema f7600; + private final Schema f7610; + private final Schema f7620; + private final Schema f7630; + private final Schema f7640; + private final Schema f7650; + private final Schema f7660; + private final Schema f7670; + private final Schema f7680; + private final Schema f7690; + private final Schema f7700; + private final Schema f7710; + private final Schema f7720; + private final Schema f7730; + private final Schema f7740; + private final Schema f7750; + private final Schema f7760; + private final Schema f7770; + private final Schema f7780; + private final Schema f7790; + private final Schema f7800; + private final Schema f7810; + private final Schema f7820; + private final Schema f7830; + private final Schema f7840; + private final Schema f7850; + private final Schema f7860; + private final Schema f7870; + private final Schema f7880; + private final Schema f7890; + private final Schema f7900; + private final Schema f7910; + private final Schema f7920; + private final Schema f7930; + private final Schema f7940; + private final Schema f7950; + private final Schema f7960; + private final Schema f7970; + private final Schema f7980; + private final Schema f7990; + private final Schema f8000; + private final Schema f8010; + private final Schema f8020; + private final Schema f8030; + private final Schema f8040; + private final Schema f8050; + private final Schema f8060; + private final Schema f8070; + private final Schema f8080; + private final Schema f8090; + private final Schema f8100; + private final Schema f8110; + private final Schema f8120; + private final Schema f8130; + private final Schema f8140; + private final Schema f8150; + private final Schema f8160; + private final Schema f8170; + private final Schema f8180; + private final Schema f8190; + private final Schema f8200; + private final Schema f8210; + private final Schema f8220; + private final Schema f8230; + private final Schema f8240; + private final Schema f8250; + private final Schema f8260; + private final Schema f8270; + private final Schema f8280; + private final Schema f8290; + private final Schema f8300; + private final Schema f8310; + private final Schema f8320; + private final Schema f8330; + private final Schema f8340; + private final Schema f8350; + private final Schema f8360; + private final Schema f8370; + private final Schema f8380; + private final Schema f8390; + private final Schema f8400; + private final Schema f8410; + private final Schema f8420; + private final Schema f8430; + private final Schema f8440; + private final Schema f8450; + private final Schema f8460; + private final Schema f8470; + private final Schema f8480; + private final Schema f8490; + private final Schema f8500; + private final Schema f8510; + private final Schema f8520; + private final Schema f8530; + private final Schema f8540; + private final Schema f8550; + private final Schema f8560; + private final Schema f8570; + private final Schema f8580; + private final Schema f8590; + private final Schema f8600; + private final Schema f8610; + private final Schema f8620; + private final Schema f8630; + private final Schema f8640; + private final Schema f8650; + private final Schema f8660; + private final Schema f8670; + private final Schema f8680; + private final Schema f8690; + private final Schema f8700; + private final Schema f8710; + private final Schema f8720; + private final Schema f8730; + private final Schema f8740; + private final Schema f8750; + private final Schema f8760; + private final Schema f8770; + private final Schema f8780; + private final Schema f8790; + private final Schema f8800; + private final Schema f8810; + private final Schema f8820; + private final Schema f8830; + private final Schema f8840; + private final Schema f8850; + private final Schema f8860; + private final Schema f8870; + private final Schema f8880; + private final Schema f8890; + private final Schema f8900; + private final Schema f8910; + private final Schema f8920; + private final Schema f8930; + private final Schema f8940; + private final Schema f8950; + private final Schema f8960; + private final Schema f8970; + private final Schema f8980; + private final Schema f8990; + private final Schema f9000; + private final Schema f9010; + private final Schema f9020; + private final Schema f9030; + private final Schema f9040; + private final Schema f9050; + private final Schema f9060; + private final Schema f9070; + private final Schema f9080; + private final Schema f9090; + private final Schema f9100; + private final Schema f9110; + private final Schema f9120; + private final Schema f9130; + private final Schema f9140; + private final Schema f9150; + private final Schema f9160; + private final Schema f9170; + private final Schema f9180; + private final Schema f9190; + private final Schema f9200; + private final Schema f9210; + private final Schema f9220; + private final Schema f9230; + private final Schema f9240; + private final Schema f9250; + private final Schema f9260; + private final Schema f9270; + private final Schema f9280; + private final Schema f9290; + private final Schema f9300; + private final Schema f9310; + private final Schema f9320; + private final Schema f9330; + private final Schema f9340; + private final Schema f9350; + private final Schema f9360; + private final Schema f9370; + private final Schema f9380; + private final Schema f9390; + private final Schema f9400; + private final Schema f9410; + private final Schema f9420; + private final Schema f9430; + private final Schema f9440; + private final Schema f9450; + private final Schema f9460; + private final Schema f9470; + private final Schema f9480; + private final Schema f9490; + private final Schema f9500; + private final Schema f9510; + private final Schema f9520; + private final Schema f9530; + private final Schema f9540; + private final Schema f9550; + private final Schema f9560; + private final Schema f9570; + private final Schema f9580; + private final Schema f9590; + private final Schema f9600; + private final Schema f9610; + private final Schema f9620; + private final Schema f9630; + private final Schema f9640; + private final Schema f9650; + private final Schema f9660; + private final Schema f9670; + private final Schema f9680; + private final Schema f9690; + private final Schema f9700; + private final Schema f9710; + private final Schema f9720; + private final Schema f9730; + private final Schema f9740; + private final Schema f9750; + private final Schema f9760; + private final Schema f9770; + private final Schema f9780; + private final Schema f9790; + private final Schema f9800; + private final Schema f9810; + private final Schema f9820; + private final Schema f9830; + private final Schema f9840; + private final Schema f9850; + private final Schema f9860; + private final Schema f9870; + private final Schema f9880; + private final Schema f9890; + private final Schema f9900; + private final Schema f9910; + private final Schema f9920; + private final Schema f9930; + private final Schema f9940; + private final Schema f9950; + private final Schema f9960; + private final Schema f9970; + private final Schema f9980; + private final Schema f9990; + + public FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema_GenericDeserializer_836892732_836892732(Schema readerSchema) { + this.readerSchema = readerSchema; + this.f00 = readerSchema.getField("F0").schema(); + this.f10 = readerSchema.getField("F1").schema(); + this.f20 = readerSchema.getField("F2").schema(); + this.f30 = readerSchema.getField("F3").schema(); + this.f40 = readerSchema.getField("F4").schema(); + this.f50 = readerSchema.getField("F5").schema(); + this.f60 = readerSchema.getField("F6").schema(); + this.f70 = readerSchema.getField("F7").schema(); + this.f80 = readerSchema.getField("F8").schema(); + this.f90 = readerSchema.getField("F9").schema(); + this.f100 = readerSchema.getField("F10").schema(); + this.f110 = readerSchema.getField("F11").schema(); + this.f120 = readerSchema.getField("F12").schema(); + this.f130 = readerSchema.getField("F13").schema(); + this.f140 = readerSchema.getField("F14").schema(); + this.f150 = readerSchema.getField("F15").schema(); + this.f160 = readerSchema.getField("F16").schema(); + this.f170 = readerSchema.getField("F17").schema(); + this.f180 = readerSchema.getField("F18").schema(); + this.f190 = readerSchema.getField("F19").schema(); + this.f200 = readerSchema.getField("F20").schema(); + this.f210 = readerSchema.getField("F21").schema(); + this.f220 = readerSchema.getField("F22").schema(); + this.f230 = readerSchema.getField("F23").schema(); + this.f240 = readerSchema.getField("F24").schema(); + this.f250 = readerSchema.getField("F25").schema(); + this.f260 = readerSchema.getField("F26").schema(); + this.f270 = readerSchema.getField("F27").schema(); + this.f280 = readerSchema.getField("F28").schema(); + this.f290 = readerSchema.getField("F29").schema(); + this.f300 = readerSchema.getField("F30").schema(); + this.f310 = readerSchema.getField("F31").schema(); + this.f320 = readerSchema.getField("F32").schema(); + this.f330 = readerSchema.getField("F33").schema(); + this.f340 = readerSchema.getField("F34").schema(); + this.f350 = readerSchema.getField("F35").schema(); + this.f360 = readerSchema.getField("F36").schema(); + this.f370 = readerSchema.getField("F37").schema(); + this.f380 = readerSchema.getField("F38").schema(); + this.f390 = readerSchema.getField("F39").schema(); + this.f400 = readerSchema.getField("F40").schema(); + this.f410 = readerSchema.getField("F41").schema(); + this.f420 = readerSchema.getField("F42").schema(); + this.f430 = readerSchema.getField("F43").schema(); + this.f440 = readerSchema.getField("F44").schema(); + this.f450 = readerSchema.getField("F45").schema(); + this.f460 = readerSchema.getField("F46").schema(); + this.f470 = readerSchema.getField("F47").schema(); + this.f480 = readerSchema.getField("F48").schema(); + this.f490 = readerSchema.getField("F49").schema(); + this.f500 = readerSchema.getField("F50").schema(); + this.f510 = readerSchema.getField("F51").schema(); + this.f520 = readerSchema.getField("F52").schema(); + this.f530 = readerSchema.getField("F53").schema(); + this.f540 = readerSchema.getField("F54").schema(); + this.f550 = readerSchema.getField("F55").schema(); + this.f560 = readerSchema.getField("F56").schema(); + this.f570 = readerSchema.getField("F57").schema(); + this.f580 = readerSchema.getField("F58").schema(); + this.f590 = readerSchema.getField("F59").schema(); + this.f600 = readerSchema.getField("F60").schema(); + this.f610 = readerSchema.getField("F61").schema(); + this.f620 = readerSchema.getField("F62").schema(); + this.f630 = readerSchema.getField("F63").schema(); + this.f640 = readerSchema.getField("F64").schema(); + this.f650 = readerSchema.getField("F65").schema(); + this.f660 = readerSchema.getField("F66").schema(); + this.f670 = readerSchema.getField("F67").schema(); + this.f680 = readerSchema.getField("F68").schema(); + this.f690 = readerSchema.getField("F69").schema(); + this.f700 = readerSchema.getField("F70").schema(); + this.f710 = readerSchema.getField("F71").schema(); + this.f720 = readerSchema.getField("F72").schema(); + this.f730 = readerSchema.getField("F73").schema(); + this.f740 = readerSchema.getField("F74").schema(); + this.f750 = readerSchema.getField("F75").schema(); + this.f760 = readerSchema.getField("F76").schema(); + this.f770 = readerSchema.getField("F77").schema(); + this.f780 = readerSchema.getField("F78").schema(); + this.f790 = readerSchema.getField("F79").schema(); + this.f800 = readerSchema.getField("F80").schema(); + this.f810 = readerSchema.getField("F81").schema(); + this.f820 = readerSchema.getField("F82").schema(); + this.f830 = readerSchema.getField("F83").schema(); + this.f840 = readerSchema.getField("F84").schema(); + this.f850 = readerSchema.getField("F85").schema(); + this.f860 = readerSchema.getField("F86").schema(); + this.f870 = readerSchema.getField("F87").schema(); + this.f880 = readerSchema.getField("F88").schema(); + this.f890 = readerSchema.getField("F89").schema(); + this.f900 = readerSchema.getField("F90").schema(); + this.f910 = readerSchema.getField("F91").schema(); + this.f920 = readerSchema.getField("F92").schema(); + this.f930 = readerSchema.getField("F93").schema(); + this.f940 = readerSchema.getField("F94").schema(); + this.f950 = readerSchema.getField("F95").schema(); + this.f960 = readerSchema.getField("F96").schema(); + this.f970 = readerSchema.getField("F97").schema(); + this.f980 = readerSchema.getField("F98").schema(); + this.f990 = readerSchema.getField("F99").schema(); + this.f1000 = readerSchema.getField("F100").schema(); + this.f1010 = readerSchema.getField("F101").schema(); + this.f1020 = readerSchema.getField("F102").schema(); + this.f1030 = readerSchema.getField("F103").schema(); + this.f1040 = readerSchema.getField("F104").schema(); + this.f1050 = readerSchema.getField("F105").schema(); + this.f1060 = readerSchema.getField("F106").schema(); + this.f1070 = readerSchema.getField("F107").schema(); + this.f1080 = readerSchema.getField("F108").schema(); + this.f1090 = readerSchema.getField("F109").schema(); + this.f1100 = readerSchema.getField("F110").schema(); + this.f1110 = readerSchema.getField("F111").schema(); + this.f1120 = readerSchema.getField("F112").schema(); + this.f1130 = readerSchema.getField("F113").schema(); + this.f1140 = readerSchema.getField("F114").schema(); + this.f1150 = readerSchema.getField("F115").schema(); + this.f1160 = readerSchema.getField("F116").schema(); + this.f1170 = readerSchema.getField("F117").schema(); + this.f1180 = readerSchema.getField("F118").schema(); + this.f1190 = readerSchema.getField("F119").schema(); + this.f1200 = readerSchema.getField("F120").schema(); + this.f1210 = readerSchema.getField("F121").schema(); + this.f1220 = readerSchema.getField("F122").schema(); + this.f1230 = readerSchema.getField("F123").schema(); + this.f1240 = readerSchema.getField("F124").schema(); + this.f1250 = readerSchema.getField("F125").schema(); + this.f1260 = readerSchema.getField("F126").schema(); + this.f1270 = readerSchema.getField("F127").schema(); + this.f1280 = readerSchema.getField("F128").schema(); + this.f1290 = readerSchema.getField("F129").schema(); + this.f1300 = readerSchema.getField("F130").schema(); + this.f1310 = readerSchema.getField("F131").schema(); + this.f1320 = readerSchema.getField("F132").schema(); + this.f1330 = readerSchema.getField("F133").schema(); + this.f1340 = readerSchema.getField("F134").schema(); + this.f1350 = readerSchema.getField("F135").schema(); + this.f1360 = readerSchema.getField("F136").schema(); + this.f1370 = readerSchema.getField("F137").schema(); + this.f1380 = readerSchema.getField("F138").schema(); + this.f1390 = readerSchema.getField("F139").schema(); + this.f1400 = readerSchema.getField("F140").schema(); + this.f1410 = readerSchema.getField("F141").schema(); + this.f1420 = readerSchema.getField("F142").schema(); + this.f1430 = readerSchema.getField("F143").schema(); + this.f1440 = readerSchema.getField("F144").schema(); + this.f1450 = readerSchema.getField("F145").schema(); + this.f1460 = readerSchema.getField("F146").schema(); + this.f1470 = readerSchema.getField("F147").schema(); + this.f1480 = readerSchema.getField("F148").schema(); + this.f1490 = readerSchema.getField("F149").schema(); + this.f1500 = readerSchema.getField("F150").schema(); + this.f1510 = readerSchema.getField("F151").schema(); + this.f1520 = readerSchema.getField("F152").schema(); + this.f1530 = readerSchema.getField("F153").schema(); + this.f1540 = readerSchema.getField("F154").schema(); + this.f1550 = readerSchema.getField("F155").schema(); + this.f1560 = readerSchema.getField("F156").schema(); + this.f1570 = readerSchema.getField("F157").schema(); + this.f1580 = readerSchema.getField("F158").schema(); + this.f1590 = readerSchema.getField("F159").schema(); + this.f1600 = readerSchema.getField("F160").schema(); + this.f1610 = readerSchema.getField("F161").schema(); + this.f1620 = readerSchema.getField("F162").schema(); + this.f1630 = readerSchema.getField("F163").schema(); + this.f1640 = readerSchema.getField("F164").schema(); + this.f1650 = readerSchema.getField("F165").schema(); + this.f1660 = readerSchema.getField("F166").schema(); + this.f1670 = readerSchema.getField("F167").schema(); + this.f1680 = readerSchema.getField("F168").schema(); + this.f1690 = readerSchema.getField("F169").schema(); + this.f1700 = readerSchema.getField("F170").schema(); + this.f1710 = readerSchema.getField("F171").schema(); + this.f1720 = readerSchema.getField("F172").schema(); + this.f1730 = readerSchema.getField("F173").schema(); + this.f1740 = readerSchema.getField("F174").schema(); + this.f1750 = readerSchema.getField("F175").schema(); + this.f1760 = readerSchema.getField("F176").schema(); + this.f1770 = readerSchema.getField("F177").schema(); + this.f1780 = readerSchema.getField("F178").schema(); + this.f1790 = readerSchema.getField("F179").schema(); + this.f1800 = readerSchema.getField("F180").schema(); + this.f1810 = readerSchema.getField("F181").schema(); + this.f1820 = readerSchema.getField("F182").schema(); + this.f1830 = readerSchema.getField("F183").schema(); + this.f1840 = readerSchema.getField("F184").schema(); + this.f1850 = readerSchema.getField("F185").schema(); + this.f1860 = readerSchema.getField("F186").schema(); + this.f1870 = readerSchema.getField("F187").schema(); + this.f1880 = readerSchema.getField("F188").schema(); + this.f1890 = readerSchema.getField("F189").schema(); + this.f1900 = readerSchema.getField("F190").schema(); + this.f1910 = readerSchema.getField("F191").schema(); + this.f1920 = readerSchema.getField("F192").schema(); + this.f1930 = readerSchema.getField("F193").schema(); + this.f1940 = readerSchema.getField("F194").schema(); + this.f1950 = readerSchema.getField("F195").schema(); + this.f1960 = readerSchema.getField("F196").schema(); + this.f1970 = readerSchema.getField("F197").schema(); + this.f1980 = readerSchema.getField("F198").schema(); + this.f1990 = readerSchema.getField("F199").schema(); + this.f2000 = readerSchema.getField("F200").schema(); + this.f2010 = readerSchema.getField("F201").schema(); + this.f2020 = readerSchema.getField("F202").schema(); + this.f2030 = readerSchema.getField("F203").schema(); + this.f2040 = readerSchema.getField("F204").schema(); + this.f2050 = readerSchema.getField("F205").schema(); + this.f2060 = readerSchema.getField("F206").schema(); + this.f2070 = readerSchema.getField("F207").schema(); + this.f2080 = readerSchema.getField("F208").schema(); + this.f2090 = readerSchema.getField("F209").schema(); + this.f2100 = readerSchema.getField("F210").schema(); + this.f2110 = readerSchema.getField("F211").schema(); + this.f2120 = readerSchema.getField("F212").schema(); + this.f2130 = readerSchema.getField("F213").schema(); + this.f2140 = readerSchema.getField("F214").schema(); + this.f2150 = readerSchema.getField("F215").schema(); + this.f2160 = readerSchema.getField("F216").schema(); + this.f2170 = readerSchema.getField("F217").schema(); + this.f2180 = readerSchema.getField("F218").schema(); + this.f2190 = readerSchema.getField("F219").schema(); + this.f2200 = readerSchema.getField("F220").schema(); + this.f2210 = readerSchema.getField("F221").schema(); + this.f2220 = readerSchema.getField("F222").schema(); + this.f2230 = readerSchema.getField("F223").schema(); + this.f2240 = readerSchema.getField("F224").schema(); + this.f2250 = readerSchema.getField("F225").schema(); + this.f2260 = readerSchema.getField("F226").schema(); + this.f2270 = readerSchema.getField("F227").schema(); + this.f2280 = readerSchema.getField("F228").schema(); + this.f2290 = readerSchema.getField("F229").schema(); + this.f2300 = readerSchema.getField("F230").schema(); + this.f2310 = readerSchema.getField("F231").schema(); + this.f2320 = readerSchema.getField("F232").schema(); + this.f2330 = readerSchema.getField("F233").schema(); + this.f2340 = readerSchema.getField("F234").schema(); + this.f2350 = readerSchema.getField("F235").schema(); + this.f2360 = readerSchema.getField("F236").schema(); + this.f2370 = readerSchema.getField("F237").schema(); + this.f2380 = readerSchema.getField("F238").schema(); + this.f2390 = readerSchema.getField("F239").schema(); + this.f2400 = readerSchema.getField("F240").schema(); + this.f2410 = readerSchema.getField("F241").schema(); + this.f2420 = readerSchema.getField("F242").schema(); + this.f2430 = readerSchema.getField("F243").schema(); + this.f2440 = readerSchema.getField("F244").schema(); + this.f2450 = readerSchema.getField("F245").schema(); + this.f2460 = readerSchema.getField("F246").schema(); + this.f2470 = readerSchema.getField("F247").schema(); + this.f2480 = readerSchema.getField("F248").schema(); + this.f2490 = readerSchema.getField("F249").schema(); + this.f2500 = readerSchema.getField("F250").schema(); + this.f2510 = readerSchema.getField("F251").schema(); + this.f2520 = readerSchema.getField("F252").schema(); + this.f2530 = readerSchema.getField("F253").schema(); + this.f2540 = readerSchema.getField("F254").schema(); + this.f2550 = readerSchema.getField("F255").schema(); + this.f2560 = readerSchema.getField("F256").schema(); + this.f2570 = readerSchema.getField("F257").schema(); + this.f2580 = readerSchema.getField("F258").schema(); + this.f2590 = readerSchema.getField("F259").schema(); + this.f2600 = readerSchema.getField("F260").schema(); + this.f2610 = readerSchema.getField("F261").schema(); + this.f2620 = readerSchema.getField("F262").schema(); + this.f2630 = readerSchema.getField("F263").schema(); + this.f2640 = readerSchema.getField("F264").schema(); + this.f2650 = readerSchema.getField("F265").schema(); + this.f2660 = readerSchema.getField("F266").schema(); + this.f2670 = readerSchema.getField("F267").schema(); + this.f2680 = readerSchema.getField("F268").schema(); + this.f2690 = readerSchema.getField("F269").schema(); + this.f2700 = readerSchema.getField("F270").schema(); + this.f2710 = readerSchema.getField("F271").schema(); + this.f2720 = readerSchema.getField("F272").schema(); + this.f2730 = readerSchema.getField("F273").schema(); + this.f2740 = readerSchema.getField("F274").schema(); + this.f2750 = readerSchema.getField("F275").schema(); + this.f2760 = readerSchema.getField("F276").schema(); + this.f2770 = readerSchema.getField("F277").schema(); + this.f2780 = readerSchema.getField("F278").schema(); + this.f2790 = readerSchema.getField("F279").schema(); + this.f2800 = readerSchema.getField("F280").schema(); + this.f2810 = readerSchema.getField("F281").schema(); + this.f2820 = readerSchema.getField("F282").schema(); + this.f2830 = readerSchema.getField("F283").schema(); + this.f2840 = readerSchema.getField("F284").schema(); + this.f2850 = readerSchema.getField("F285").schema(); + this.f2860 = readerSchema.getField("F286").schema(); + this.f2870 = readerSchema.getField("F287").schema(); + this.f2880 = readerSchema.getField("F288").schema(); + this.f2890 = readerSchema.getField("F289").schema(); + this.f2900 = readerSchema.getField("F290").schema(); + this.f2910 = readerSchema.getField("F291").schema(); + this.f2920 = readerSchema.getField("F292").schema(); + this.f2930 = readerSchema.getField("F293").schema(); + this.f2940 = readerSchema.getField("F294").schema(); + this.f2950 = readerSchema.getField("F295").schema(); + this.f2960 = readerSchema.getField("F296").schema(); + this.f2970 = readerSchema.getField("F297").schema(); + this.f2980 = readerSchema.getField("F298").schema(); + this.f2990 = readerSchema.getField("F299").schema(); + this.f3000 = readerSchema.getField("F300").schema(); + this.f3010 = readerSchema.getField("F301").schema(); + this.f3020 = readerSchema.getField("F302").schema(); + this.f3030 = readerSchema.getField("F303").schema(); + this.f3040 = readerSchema.getField("F304").schema(); + this.f3050 = readerSchema.getField("F305").schema(); + this.f3060 = readerSchema.getField("F306").schema(); + this.f3070 = readerSchema.getField("F307").schema(); + this.f3080 = readerSchema.getField("F308").schema(); + this.f3090 = readerSchema.getField("F309").schema(); + this.f3100 = readerSchema.getField("F310").schema(); + this.f3110 = readerSchema.getField("F311").schema(); + this.f3120 = readerSchema.getField("F312").schema(); + this.f3130 = readerSchema.getField("F313").schema(); + this.f3140 = readerSchema.getField("F314").schema(); + this.f3150 = readerSchema.getField("F315").schema(); + this.f3160 = readerSchema.getField("F316").schema(); + this.f3170 = readerSchema.getField("F317").schema(); + this.f3180 = readerSchema.getField("F318").schema(); + this.f3190 = readerSchema.getField("F319").schema(); + this.f3200 = readerSchema.getField("F320").schema(); + this.f3210 = readerSchema.getField("F321").schema(); + this.f3220 = readerSchema.getField("F322").schema(); + this.f3230 = readerSchema.getField("F323").schema(); + this.f3240 = readerSchema.getField("F324").schema(); + this.f3250 = readerSchema.getField("F325").schema(); + this.f3260 = readerSchema.getField("F326").schema(); + this.f3270 = readerSchema.getField("F327").schema(); + this.f3280 = readerSchema.getField("F328").schema(); + this.f3290 = readerSchema.getField("F329").schema(); + this.f3300 = readerSchema.getField("F330").schema(); + this.f3310 = readerSchema.getField("F331").schema(); + this.f3320 = readerSchema.getField("F332").schema(); + this.f3330 = readerSchema.getField("F333").schema(); + this.f3340 = readerSchema.getField("F334").schema(); + this.f3350 = readerSchema.getField("F335").schema(); + this.f3360 = readerSchema.getField("F336").schema(); + this.f3370 = readerSchema.getField("F337").schema(); + this.f3380 = readerSchema.getField("F338").schema(); + this.f3390 = readerSchema.getField("F339").schema(); + this.f3400 = readerSchema.getField("F340").schema(); + this.f3410 = readerSchema.getField("F341").schema(); + this.f3420 = readerSchema.getField("F342").schema(); + this.f3430 = readerSchema.getField("F343").schema(); + this.f3440 = readerSchema.getField("F344").schema(); + this.f3450 = readerSchema.getField("F345").schema(); + this.f3460 = readerSchema.getField("F346").schema(); + this.f3470 = readerSchema.getField("F347").schema(); + this.f3480 = readerSchema.getField("F348").schema(); + this.f3490 = readerSchema.getField("F349").schema(); + this.f3500 = readerSchema.getField("F350").schema(); + this.f3510 = readerSchema.getField("F351").schema(); + this.f3520 = readerSchema.getField("F352").schema(); + this.f3530 = readerSchema.getField("F353").schema(); + this.f3540 = readerSchema.getField("F354").schema(); + this.f3550 = readerSchema.getField("F355").schema(); + this.f3560 = readerSchema.getField("F356").schema(); + this.f3570 = readerSchema.getField("F357").schema(); + this.f3580 = readerSchema.getField("F358").schema(); + this.f3590 = readerSchema.getField("F359").schema(); + this.f3600 = readerSchema.getField("F360").schema(); + this.f3610 = readerSchema.getField("F361").schema(); + this.f3620 = readerSchema.getField("F362").schema(); + this.f3630 = readerSchema.getField("F363").schema(); + this.f3640 = readerSchema.getField("F364").schema(); + this.f3650 = readerSchema.getField("F365").schema(); + this.f3660 = readerSchema.getField("F366").schema(); + this.f3670 = readerSchema.getField("F367").schema(); + this.f3680 = readerSchema.getField("F368").schema(); + this.f3690 = readerSchema.getField("F369").schema(); + this.f3700 = readerSchema.getField("F370").schema(); + this.f3710 = readerSchema.getField("F371").schema(); + this.f3720 = readerSchema.getField("F372").schema(); + this.f3730 = readerSchema.getField("F373").schema(); + this.f3740 = readerSchema.getField("F374").schema(); + this.f3750 = readerSchema.getField("F375").schema(); + this.f3760 = readerSchema.getField("F376").schema(); + this.f3770 = readerSchema.getField("F377").schema(); + this.f3780 = readerSchema.getField("F378").schema(); + this.f3790 = readerSchema.getField("F379").schema(); + this.f3800 = readerSchema.getField("F380").schema(); + this.f3810 = readerSchema.getField("F381").schema(); + this.f3820 = readerSchema.getField("F382").schema(); + this.f3830 = readerSchema.getField("F383").schema(); + this.f3840 = readerSchema.getField("F384").schema(); + this.f3850 = readerSchema.getField("F385").schema(); + this.f3860 = readerSchema.getField("F386").schema(); + this.f3870 = readerSchema.getField("F387").schema(); + this.f3880 = readerSchema.getField("F388").schema(); + this.f3890 = readerSchema.getField("F389").schema(); + this.f3900 = readerSchema.getField("F390").schema(); + this.f3910 = readerSchema.getField("F391").schema(); + this.f3920 = readerSchema.getField("F392").schema(); + this.f3930 = readerSchema.getField("F393").schema(); + this.f3940 = readerSchema.getField("F394").schema(); + this.f3950 = readerSchema.getField("F395").schema(); + this.f3960 = readerSchema.getField("F396").schema(); + this.f3970 = readerSchema.getField("F397").schema(); + this.f3980 = readerSchema.getField("F398").schema(); + this.f3990 = readerSchema.getField("F399").schema(); + this.f4000 = readerSchema.getField("F400").schema(); + this.f4010 = readerSchema.getField("F401").schema(); + this.f4020 = readerSchema.getField("F402").schema(); + this.f4030 = readerSchema.getField("F403").schema(); + this.f4040 = readerSchema.getField("F404").schema(); + this.f4050 = readerSchema.getField("F405").schema(); + this.f4060 = readerSchema.getField("F406").schema(); + this.f4070 = readerSchema.getField("F407").schema(); + this.f4080 = readerSchema.getField("F408").schema(); + this.f4090 = readerSchema.getField("F409").schema(); + this.f4100 = readerSchema.getField("F410").schema(); + this.f4110 = readerSchema.getField("F411").schema(); + this.f4120 = readerSchema.getField("F412").schema(); + this.f4130 = readerSchema.getField("F413").schema(); + this.f4140 = readerSchema.getField("F414").schema(); + this.f4150 = readerSchema.getField("F415").schema(); + this.f4160 = readerSchema.getField("F416").schema(); + this.f4170 = readerSchema.getField("F417").schema(); + this.f4180 = readerSchema.getField("F418").schema(); + this.f4190 = readerSchema.getField("F419").schema(); + this.f4200 = readerSchema.getField("F420").schema(); + this.f4210 = readerSchema.getField("F421").schema(); + this.f4220 = readerSchema.getField("F422").schema(); + this.f4230 = readerSchema.getField("F423").schema(); + this.f4240 = readerSchema.getField("F424").schema(); + this.f4250 = readerSchema.getField("F425").schema(); + this.f4260 = readerSchema.getField("F426").schema(); + this.f4270 = readerSchema.getField("F427").schema(); + this.f4280 = readerSchema.getField("F428").schema(); + this.f4290 = readerSchema.getField("F429").schema(); + this.f4300 = readerSchema.getField("F430").schema(); + this.f4310 = readerSchema.getField("F431").schema(); + this.f4320 = readerSchema.getField("F432").schema(); + this.f4330 = readerSchema.getField("F433").schema(); + this.f4340 = readerSchema.getField("F434").schema(); + this.f4350 = readerSchema.getField("F435").schema(); + this.f4360 = readerSchema.getField("F436").schema(); + this.f4370 = readerSchema.getField("F437").schema(); + this.f4380 = readerSchema.getField("F438").schema(); + this.f4390 = readerSchema.getField("F439").schema(); + this.f4400 = readerSchema.getField("F440").schema(); + this.f4410 = readerSchema.getField("F441").schema(); + this.f4420 = readerSchema.getField("F442").schema(); + this.f4430 = readerSchema.getField("F443").schema(); + this.f4440 = readerSchema.getField("F444").schema(); + this.f4450 = readerSchema.getField("F445").schema(); + this.f4460 = readerSchema.getField("F446").schema(); + this.f4470 = readerSchema.getField("F447").schema(); + this.f4480 = readerSchema.getField("F448").schema(); + this.f4490 = readerSchema.getField("F449").schema(); + this.f4500 = readerSchema.getField("F450").schema(); + this.f4510 = readerSchema.getField("F451").schema(); + this.f4520 = readerSchema.getField("F452").schema(); + this.f4530 = readerSchema.getField("F453").schema(); + this.f4540 = readerSchema.getField("F454").schema(); + this.f4550 = readerSchema.getField("F455").schema(); + this.f4560 = readerSchema.getField("F456").schema(); + this.f4570 = readerSchema.getField("F457").schema(); + this.f4580 = readerSchema.getField("F458").schema(); + this.f4590 = readerSchema.getField("F459").schema(); + this.f4600 = readerSchema.getField("F460").schema(); + this.f4610 = readerSchema.getField("F461").schema(); + this.f4620 = readerSchema.getField("F462").schema(); + this.f4630 = readerSchema.getField("F463").schema(); + this.f4640 = readerSchema.getField("F464").schema(); + this.f4650 = readerSchema.getField("F465").schema(); + this.f4660 = readerSchema.getField("F466").schema(); + this.f4670 = readerSchema.getField("F467").schema(); + this.f4680 = readerSchema.getField("F468").schema(); + this.f4690 = readerSchema.getField("F469").schema(); + this.f4700 = readerSchema.getField("F470").schema(); + this.f4710 = readerSchema.getField("F471").schema(); + this.f4720 = readerSchema.getField("F472").schema(); + this.f4730 = readerSchema.getField("F473").schema(); + this.f4740 = readerSchema.getField("F474").schema(); + this.f4750 = readerSchema.getField("F475").schema(); + this.f4760 = readerSchema.getField("F476").schema(); + this.f4770 = readerSchema.getField("F477").schema(); + this.f4780 = readerSchema.getField("F478").schema(); + this.f4790 = readerSchema.getField("F479").schema(); + this.f4800 = readerSchema.getField("F480").schema(); + this.f4810 = readerSchema.getField("F481").schema(); + this.f4820 = readerSchema.getField("F482").schema(); + this.f4830 = readerSchema.getField("F483").schema(); + this.f4840 = readerSchema.getField("F484").schema(); + this.f4850 = readerSchema.getField("F485").schema(); + this.f4860 = readerSchema.getField("F486").schema(); + this.f4870 = readerSchema.getField("F487").schema(); + this.f4880 = readerSchema.getField("F488").schema(); + this.f4890 = readerSchema.getField("F489").schema(); + this.f4900 = readerSchema.getField("F490").schema(); + this.f4910 = readerSchema.getField("F491").schema(); + this.f4920 = readerSchema.getField("F492").schema(); + this.f4930 = readerSchema.getField("F493").schema(); + this.f4940 = readerSchema.getField("F494").schema(); + this.f4950 = readerSchema.getField("F495").schema(); + this.f4960 = readerSchema.getField("F496").schema(); + this.f4970 = readerSchema.getField("F497").schema(); + this.f4980 = readerSchema.getField("F498").schema(); + this.f4990 = readerSchema.getField("F499").schema(); + this.f5000 = readerSchema.getField("F500").schema(); + this.f5010 = readerSchema.getField("F501").schema(); + this.f5020 = readerSchema.getField("F502").schema(); + this.f5030 = readerSchema.getField("F503").schema(); + this.f5040 = readerSchema.getField("F504").schema(); + this.f5050 = readerSchema.getField("F505").schema(); + this.f5060 = readerSchema.getField("F506").schema(); + this.f5070 = readerSchema.getField("F507").schema(); + this.f5080 = readerSchema.getField("F508").schema(); + this.f5090 = readerSchema.getField("F509").schema(); + this.f5100 = readerSchema.getField("F510").schema(); + this.f5110 = readerSchema.getField("F511").schema(); + this.f5120 = readerSchema.getField("F512").schema(); + this.f5130 = readerSchema.getField("F513").schema(); + this.f5140 = readerSchema.getField("F514").schema(); + this.f5150 = readerSchema.getField("F515").schema(); + this.f5160 = readerSchema.getField("F516").schema(); + this.f5170 = readerSchema.getField("F517").schema(); + this.f5180 = readerSchema.getField("F518").schema(); + this.f5190 = readerSchema.getField("F519").schema(); + this.f5200 = readerSchema.getField("F520").schema(); + this.f5210 = readerSchema.getField("F521").schema(); + this.f5220 = readerSchema.getField("F522").schema(); + this.f5230 = readerSchema.getField("F523").schema(); + this.f5240 = readerSchema.getField("F524").schema(); + this.f5250 = readerSchema.getField("F525").schema(); + this.f5260 = readerSchema.getField("F526").schema(); + this.f5270 = readerSchema.getField("F527").schema(); + this.f5280 = readerSchema.getField("F528").schema(); + this.f5290 = readerSchema.getField("F529").schema(); + this.f5300 = readerSchema.getField("F530").schema(); + this.f5310 = readerSchema.getField("F531").schema(); + this.f5320 = readerSchema.getField("F532").schema(); + this.f5330 = readerSchema.getField("F533").schema(); + this.f5340 = readerSchema.getField("F534").schema(); + this.f5350 = readerSchema.getField("F535").schema(); + this.f5360 = readerSchema.getField("F536").schema(); + this.f5370 = readerSchema.getField("F537").schema(); + this.f5380 = readerSchema.getField("F538").schema(); + this.f5390 = readerSchema.getField("F539").schema(); + this.f5400 = readerSchema.getField("F540").schema(); + this.f5410 = readerSchema.getField("F541").schema(); + this.f5420 = readerSchema.getField("F542").schema(); + this.f5430 = readerSchema.getField("F543").schema(); + this.f5440 = readerSchema.getField("F544").schema(); + this.f5450 = readerSchema.getField("F545").schema(); + this.f5460 = readerSchema.getField("F546").schema(); + this.f5470 = readerSchema.getField("F547").schema(); + this.f5480 = readerSchema.getField("F548").schema(); + this.f5490 = readerSchema.getField("F549").schema(); + this.f5500 = readerSchema.getField("F550").schema(); + this.f5510 = readerSchema.getField("F551").schema(); + this.f5520 = readerSchema.getField("F552").schema(); + this.f5530 = readerSchema.getField("F553").schema(); + this.f5540 = readerSchema.getField("F554").schema(); + this.f5550 = readerSchema.getField("F555").schema(); + this.f5560 = readerSchema.getField("F556").schema(); + this.f5570 = readerSchema.getField("F557").schema(); + this.f5580 = readerSchema.getField("F558").schema(); + this.f5590 = readerSchema.getField("F559").schema(); + this.f5600 = readerSchema.getField("F560").schema(); + this.f5610 = readerSchema.getField("F561").schema(); + this.f5620 = readerSchema.getField("F562").schema(); + this.f5630 = readerSchema.getField("F563").schema(); + this.f5640 = readerSchema.getField("F564").schema(); + this.f5650 = readerSchema.getField("F565").schema(); + this.f5660 = readerSchema.getField("F566").schema(); + this.f5670 = readerSchema.getField("F567").schema(); + this.f5680 = readerSchema.getField("F568").schema(); + this.f5690 = readerSchema.getField("F569").schema(); + this.f5700 = readerSchema.getField("F570").schema(); + this.f5710 = readerSchema.getField("F571").schema(); + this.f5720 = readerSchema.getField("F572").schema(); + this.f5730 = readerSchema.getField("F573").schema(); + this.f5740 = readerSchema.getField("F574").schema(); + this.f5750 = readerSchema.getField("F575").schema(); + this.f5760 = readerSchema.getField("F576").schema(); + this.f5770 = readerSchema.getField("F577").schema(); + this.f5780 = readerSchema.getField("F578").schema(); + this.f5790 = readerSchema.getField("F579").schema(); + this.f5800 = readerSchema.getField("F580").schema(); + this.f5810 = readerSchema.getField("F581").schema(); + this.f5820 = readerSchema.getField("F582").schema(); + this.f5830 = readerSchema.getField("F583").schema(); + this.f5840 = readerSchema.getField("F584").schema(); + this.f5850 = readerSchema.getField("F585").schema(); + this.f5860 = readerSchema.getField("F586").schema(); + this.f5870 = readerSchema.getField("F587").schema(); + this.f5880 = readerSchema.getField("F588").schema(); + this.f5890 = readerSchema.getField("F589").schema(); + this.f5900 = readerSchema.getField("F590").schema(); + this.f5910 = readerSchema.getField("F591").schema(); + this.f5920 = readerSchema.getField("F592").schema(); + this.f5930 = readerSchema.getField("F593").schema(); + this.f5940 = readerSchema.getField("F594").schema(); + this.f5950 = readerSchema.getField("F595").schema(); + this.f5960 = readerSchema.getField("F596").schema(); + this.f5970 = readerSchema.getField("F597").schema(); + this.f5980 = readerSchema.getField("F598").schema(); + this.f5990 = readerSchema.getField("F599").schema(); + this.f6000 = readerSchema.getField("F600").schema(); + this.f6010 = readerSchema.getField("F601").schema(); + this.f6020 = readerSchema.getField("F602").schema(); + this.f6030 = readerSchema.getField("F603").schema(); + this.f6040 = readerSchema.getField("F604").schema(); + this.f6050 = readerSchema.getField("F605").schema(); + this.f6060 = readerSchema.getField("F606").schema(); + this.f6070 = readerSchema.getField("F607").schema(); + this.f6080 = readerSchema.getField("F608").schema(); + this.f6090 = readerSchema.getField("F609").schema(); + this.f6100 = readerSchema.getField("F610").schema(); + this.f6110 = readerSchema.getField("F611").schema(); + this.f6120 = readerSchema.getField("F612").schema(); + this.f6130 = readerSchema.getField("F613").schema(); + this.f6140 = readerSchema.getField("F614").schema(); + this.f6150 = readerSchema.getField("F615").schema(); + this.f6160 = readerSchema.getField("F616").schema(); + this.f6170 = readerSchema.getField("F617").schema(); + this.f6180 = readerSchema.getField("F618").schema(); + this.f6190 = readerSchema.getField("F619").schema(); + this.f6200 = readerSchema.getField("F620").schema(); + this.f6210 = readerSchema.getField("F621").schema(); + this.f6220 = readerSchema.getField("F622").schema(); + this.f6230 = readerSchema.getField("F623").schema(); + this.f6240 = readerSchema.getField("F624").schema(); + this.f6250 = readerSchema.getField("F625").schema(); + this.f6260 = readerSchema.getField("F626").schema(); + this.f6270 = readerSchema.getField("F627").schema(); + this.f6280 = readerSchema.getField("F628").schema(); + this.f6290 = readerSchema.getField("F629").schema(); + this.f6300 = readerSchema.getField("F630").schema(); + this.f6310 = readerSchema.getField("F631").schema(); + this.f6320 = readerSchema.getField("F632").schema(); + this.f6330 = readerSchema.getField("F633").schema(); + this.f6340 = readerSchema.getField("F634").schema(); + this.f6350 = readerSchema.getField("F635").schema(); + this.f6360 = readerSchema.getField("F636").schema(); + this.f6370 = readerSchema.getField("F637").schema(); + this.f6380 = readerSchema.getField("F638").schema(); + this.f6390 = readerSchema.getField("F639").schema(); + this.f6400 = readerSchema.getField("F640").schema(); + this.f6410 = readerSchema.getField("F641").schema(); + this.f6420 = readerSchema.getField("F642").schema(); + this.f6430 = readerSchema.getField("F643").schema(); + this.f6440 = readerSchema.getField("F644").schema(); + this.f6450 = readerSchema.getField("F645").schema(); + this.f6460 = readerSchema.getField("F646").schema(); + this.f6470 = readerSchema.getField("F647").schema(); + this.f6480 = readerSchema.getField("F648").schema(); + this.f6490 = readerSchema.getField("F649").schema(); + this.f6500 = readerSchema.getField("F650").schema(); + this.f6510 = readerSchema.getField("F651").schema(); + this.f6520 = readerSchema.getField("F652").schema(); + this.f6530 = readerSchema.getField("F653").schema(); + this.f6540 = readerSchema.getField("F654").schema(); + this.f6550 = readerSchema.getField("F655").schema(); + this.f6560 = readerSchema.getField("F656").schema(); + this.f6570 = readerSchema.getField("F657").schema(); + this.f6580 = readerSchema.getField("F658").schema(); + this.f6590 = readerSchema.getField("F659").schema(); + this.f6600 = readerSchema.getField("F660").schema(); + this.f6610 = readerSchema.getField("F661").schema(); + this.f6620 = readerSchema.getField("F662").schema(); + this.f6630 = readerSchema.getField("F663").schema(); + this.f6640 = readerSchema.getField("F664").schema(); + this.f6650 = readerSchema.getField("F665").schema(); + this.f6660 = readerSchema.getField("F666").schema(); + this.f6670 = readerSchema.getField("F667").schema(); + this.f6680 = readerSchema.getField("F668").schema(); + this.f6690 = readerSchema.getField("F669").schema(); + this.f6700 = readerSchema.getField("F670").schema(); + this.f6710 = readerSchema.getField("F671").schema(); + this.f6720 = readerSchema.getField("F672").schema(); + this.f6730 = readerSchema.getField("F673").schema(); + this.f6740 = readerSchema.getField("F674").schema(); + this.f6750 = readerSchema.getField("F675").schema(); + this.f6760 = readerSchema.getField("F676").schema(); + this.f6770 = readerSchema.getField("F677").schema(); + this.f6780 = readerSchema.getField("F678").schema(); + this.f6790 = readerSchema.getField("F679").schema(); + this.f6800 = readerSchema.getField("F680").schema(); + this.f6810 = readerSchema.getField("F681").schema(); + this.f6820 = readerSchema.getField("F682").schema(); + this.f6830 = readerSchema.getField("F683").schema(); + this.f6840 = readerSchema.getField("F684").schema(); + this.f6850 = readerSchema.getField("F685").schema(); + this.f6860 = readerSchema.getField("F686").schema(); + this.f6870 = readerSchema.getField("F687").schema(); + this.f6880 = readerSchema.getField("F688").schema(); + this.f6890 = readerSchema.getField("F689").schema(); + this.f6900 = readerSchema.getField("F690").schema(); + this.f6910 = readerSchema.getField("F691").schema(); + this.f6920 = readerSchema.getField("F692").schema(); + this.f6930 = readerSchema.getField("F693").schema(); + this.f6940 = readerSchema.getField("F694").schema(); + this.f6950 = readerSchema.getField("F695").schema(); + this.f6960 = readerSchema.getField("F696").schema(); + this.f6970 = readerSchema.getField("F697").schema(); + this.f6980 = readerSchema.getField("F698").schema(); + this.f6990 = readerSchema.getField("F699").schema(); + this.f7000 = readerSchema.getField("F700").schema(); + this.f7010 = readerSchema.getField("F701").schema(); + this.f7020 = readerSchema.getField("F702").schema(); + this.f7030 = readerSchema.getField("F703").schema(); + this.f7040 = readerSchema.getField("F704").schema(); + this.f7050 = readerSchema.getField("F705").schema(); + this.f7060 = readerSchema.getField("F706").schema(); + this.f7070 = readerSchema.getField("F707").schema(); + this.f7080 = readerSchema.getField("F708").schema(); + this.f7090 = readerSchema.getField("F709").schema(); + this.f7100 = readerSchema.getField("F710").schema(); + this.f7110 = readerSchema.getField("F711").schema(); + this.f7120 = readerSchema.getField("F712").schema(); + this.f7130 = readerSchema.getField("F713").schema(); + this.f7140 = readerSchema.getField("F714").schema(); + this.f7150 = readerSchema.getField("F715").schema(); + this.f7160 = readerSchema.getField("F716").schema(); + this.f7170 = readerSchema.getField("F717").schema(); + this.f7180 = readerSchema.getField("F718").schema(); + this.f7190 = readerSchema.getField("F719").schema(); + this.f7200 = readerSchema.getField("F720").schema(); + this.f7210 = readerSchema.getField("F721").schema(); + this.f7220 = readerSchema.getField("F722").schema(); + this.f7230 = readerSchema.getField("F723").schema(); + this.f7240 = readerSchema.getField("F724").schema(); + this.f7250 = readerSchema.getField("F725").schema(); + this.f7260 = readerSchema.getField("F726").schema(); + this.f7270 = readerSchema.getField("F727").schema(); + this.f7280 = readerSchema.getField("F728").schema(); + this.f7290 = readerSchema.getField("F729").schema(); + this.f7300 = readerSchema.getField("F730").schema(); + this.f7310 = readerSchema.getField("F731").schema(); + this.f7320 = readerSchema.getField("F732").schema(); + this.f7330 = readerSchema.getField("F733").schema(); + this.f7340 = readerSchema.getField("F734").schema(); + this.f7350 = readerSchema.getField("F735").schema(); + this.f7360 = readerSchema.getField("F736").schema(); + this.f7370 = readerSchema.getField("F737").schema(); + this.f7380 = readerSchema.getField("F738").schema(); + this.f7390 = readerSchema.getField("F739").schema(); + this.f7400 = readerSchema.getField("F740").schema(); + this.f7410 = readerSchema.getField("F741").schema(); + this.f7420 = readerSchema.getField("F742").schema(); + this.f7430 = readerSchema.getField("F743").schema(); + this.f7440 = readerSchema.getField("F744").schema(); + this.f7450 = readerSchema.getField("F745").schema(); + this.f7460 = readerSchema.getField("F746").schema(); + this.f7470 = readerSchema.getField("F747").schema(); + this.f7480 = readerSchema.getField("F748").schema(); + this.f7490 = readerSchema.getField("F749").schema(); + this.f7500 = readerSchema.getField("F750").schema(); + this.f7510 = readerSchema.getField("F751").schema(); + this.f7520 = readerSchema.getField("F752").schema(); + this.f7530 = readerSchema.getField("F753").schema(); + this.f7540 = readerSchema.getField("F754").schema(); + this.f7550 = readerSchema.getField("F755").schema(); + this.f7560 = readerSchema.getField("F756").schema(); + this.f7570 = readerSchema.getField("F757").schema(); + this.f7580 = readerSchema.getField("F758").schema(); + this.f7590 = readerSchema.getField("F759").schema(); + this.f7600 = readerSchema.getField("F760").schema(); + this.f7610 = readerSchema.getField("F761").schema(); + this.f7620 = readerSchema.getField("F762").schema(); + this.f7630 = readerSchema.getField("F763").schema(); + this.f7640 = readerSchema.getField("F764").schema(); + this.f7650 = readerSchema.getField("F765").schema(); + this.f7660 = readerSchema.getField("F766").schema(); + this.f7670 = readerSchema.getField("F767").schema(); + this.f7680 = readerSchema.getField("F768").schema(); + this.f7690 = readerSchema.getField("F769").schema(); + this.f7700 = readerSchema.getField("F770").schema(); + this.f7710 = readerSchema.getField("F771").schema(); + this.f7720 = readerSchema.getField("F772").schema(); + this.f7730 = readerSchema.getField("F773").schema(); + this.f7740 = readerSchema.getField("F774").schema(); + this.f7750 = readerSchema.getField("F775").schema(); + this.f7760 = readerSchema.getField("F776").schema(); + this.f7770 = readerSchema.getField("F777").schema(); + this.f7780 = readerSchema.getField("F778").schema(); + this.f7790 = readerSchema.getField("F779").schema(); + this.f7800 = readerSchema.getField("F780").schema(); + this.f7810 = readerSchema.getField("F781").schema(); + this.f7820 = readerSchema.getField("F782").schema(); + this.f7830 = readerSchema.getField("F783").schema(); + this.f7840 = readerSchema.getField("F784").schema(); + this.f7850 = readerSchema.getField("F785").schema(); + this.f7860 = readerSchema.getField("F786").schema(); + this.f7870 = readerSchema.getField("F787").schema(); + this.f7880 = readerSchema.getField("F788").schema(); + this.f7890 = readerSchema.getField("F789").schema(); + this.f7900 = readerSchema.getField("F790").schema(); + this.f7910 = readerSchema.getField("F791").schema(); + this.f7920 = readerSchema.getField("F792").schema(); + this.f7930 = readerSchema.getField("F793").schema(); + this.f7940 = readerSchema.getField("F794").schema(); + this.f7950 = readerSchema.getField("F795").schema(); + this.f7960 = readerSchema.getField("F796").schema(); + this.f7970 = readerSchema.getField("F797").schema(); + this.f7980 = readerSchema.getField("F798").schema(); + this.f7990 = readerSchema.getField("F799").schema(); + this.f8000 = readerSchema.getField("F800").schema(); + this.f8010 = readerSchema.getField("F801").schema(); + this.f8020 = readerSchema.getField("F802").schema(); + this.f8030 = readerSchema.getField("F803").schema(); + this.f8040 = readerSchema.getField("F804").schema(); + this.f8050 = readerSchema.getField("F805").schema(); + this.f8060 = readerSchema.getField("F806").schema(); + this.f8070 = readerSchema.getField("F807").schema(); + this.f8080 = readerSchema.getField("F808").schema(); + this.f8090 = readerSchema.getField("F809").schema(); + this.f8100 = readerSchema.getField("F810").schema(); + this.f8110 = readerSchema.getField("F811").schema(); + this.f8120 = readerSchema.getField("F812").schema(); + this.f8130 = readerSchema.getField("F813").schema(); + this.f8140 = readerSchema.getField("F814").schema(); + this.f8150 = readerSchema.getField("F815").schema(); + this.f8160 = readerSchema.getField("F816").schema(); + this.f8170 = readerSchema.getField("F817").schema(); + this.f8180 = readerSchema.getField("F818").schema(); + this.f8190 = readerSchema.getField("F819").schema(); + this.f8200 = readerSchema.getField("F820").schema(); + this.f8210 = readerSchema.getField("F821").schema(); + this.f8220 = readerSchema.getField("F822").schema(); + this.f8230 = readerSchema.getField("F823").schema(); + this.f8240 = readerSchema.getField("F824").schema(); + this.f8250 = readerSchema.getField("F825").schema(); + this.f8260 = readerSchema.getField("F826").schema(); + this.f8270 = readerSchema.getField("F827").schema(); + this.f8280 = readerSchema.getField("F828").schema(); + this.f8290 = readerSchema.getField("F829").schema(); + this.f8300 = readerSchema.getField("F830").schema(); + this.f8310 = readerSchema.getField("F831").schema(); + this.f8320 = readerSchema.getField("F832").schema(); + this.f8330 = readerSchema.getField("F833").schema(); + this.f8340 = readerSchema.getField("F834").schema(); + this.f8350 = readerSchema.getField("F835").schema(); + this.f8360 = readerSchema.getField("F836").schema(); + this.f8370 = readerSchema.getField("F837").schema(); + this.f8380 = readerSchema.getField("F838").schema(); + this.f8390 = readerSchema.getField("F839").schema(); + this.f8400 = readerSchema.getField("F840").schema(); + this.f8410 = readerSchema.getField("F841").schema(); + this.f8420 = readerSchema.getField("F842").schema(); + this.f8430 = readerSchema.getField("F843").schema(); + this.f8440 = readerSchema.getField("F844").schema(); + this.f8450 = readerSchema.getField("F845").schema(); + this.f8460 = readerSchema.getField("F846").schema(); + this.f8470 = readerSchema.getField("F847").schema(); + this.f8480 = readerSchema.getField("F848").schema(); + this.f8490 = readerSchema.getField("F849").schema(); + this.f8500 = readerSchema.getField("F850").schema(); + this.f8510 = readerSchema.getField("F851").schema(); + this.f8520 = readerSchema.getField("F852").schema(); + this.f8530 = readerSchema.getField("F853").schema(); + this.f8540 = readerSchema.getField("F854").schema(); + this.f8550 = readerSchema.getField("F855").schema(); + this.f8560 = readerSchema.getField("F856").schema(); + this.f8570 = readerSchema.getField("F857").schema(); + this.f8580 = readerSchema.getField("F858").schema(); + this.f8590 = readerSchema.getField("F859").schema(); + this.f8600 = readerSchema.getField("F860").schema(); + this.f8610 = readerSchema.getField("F861").schema(); + this.f8620 = readerSchema.getField("F862").schema(); + this.f8630 = readerSchema.getField("F863").schema(); + this.f8640 = readerSchema.getField("F864").schema(); + this.f8650 = readerSchema.getField("F865").schema(); + this.f8660 = readerSchema.getField("F866").schema(); + this.f8670 = readerSchema.getField("F867").schema(); + this.f8680 = readerSchema.getField("F868").schema(); + this.f8690 = readerSchema.getField("F869").schema(); + this.f8700 = readerSchema.getField("F870").schema(); + this.f8710 = readerSchema.getField("F871").schema(); + this.f8720 = readerSchema.getField("F872").schema(); + this.f8730 = readerSchema.getField("F873").schema(); + this.f8740 = readerSchema.getField("F874").schema(); + this.f8750 = readerSchema.getField("F875").schema(); + this.f8760 = readerSchema.getField("F876").schema(); + this.f8770 = readerSchema.getField("F877").schema(); + this.f8780 = readerSchema.getField("F878").schema(); + this.f8790 = readerSchema.getField("F879").schema(); + this.f8800 = readerSchema.getField("F880").schema(); + this.f8810 = readerSchema.getField("F881").schema(); + this.f8820 = readerSchema.getField("F882").schema(); + this.f8830 = readerSchema.getField("F883").schema(); + this.f8840 = readerSchema.getField("F884").schema(); + this.f8850 = readerSchema.getField("F885").schema(); + this.f8860 = readerSchema.getField("F886").schema(); + this.f8870 = readerSchema.getField("F887").schema(); + this.f8880 = readerSchema.getField("F888").schema(); + this.f8890 = readerSchema.getField("F889").schema(); + this.f8900 = readerSchema.getField("F890").schema(); + this.f8910 = readerSchema.getField("F891").schema(); + this.f8920 = readerSchema.getField("F892").schema(); + this.f8930 = readerSchema.getField("F893").schema(); + this.f8940 = readerSchema.getField("F894").schema(); + this.f8950 = readerSchema.getField("F895").schema(); + this.f8960 = readerSchema.getField("F896").schema(); + this.f8970 = readerSchema.getField("F897").schema(); + this.f8980 = readerSchema.getField("F898").schema(); + this.f8990 = readerSchema.getField("F899").schema(); + this.f9000 = readerSchema.getField("F900").schema(); + this.f9010 = readerSchema.getField("F901").schema(); + this.f9020 = readerSchema.getField("F902").schema(); + this.f9030 = readerSchema.getField("F903").schema(); + this.f9040 = readerSchema.getField("F904").schema(); + this.f9050 = readerSchema.getField("F905").schema(); + this.f9060 = readerSchema.getField("F906").schema(); + this.f9070 = readerSchema.getField("F907").schema(); + this.f9080 = readerSchema.getField("F908").schema(); + this.f9090 = readerSchema.getField("F909").schema(); + this.f9100 = readerSchema.getField("F910").schema(); + this.f9110 = readerSchema.getField("F911").schema(); + this.f9120 = readerSchema.getField("F912").schema(); + this.f9130 = readerSchema.getField("F913").schema(); + this.f9140 = readerSchema.getField("F914").schema(); + this.f9150 = readerSchema.getField("F915").schema(); + this.f9160 = readerSchema.getField("F916").schema(); + this.f9170 = readerSchema.getField("F917").schema(); + this.f9180 = readerSchema.getField("F918").schema(); + this.f9190 = readerSchema.getField("F919").schema(); + this.f9200 = readerSchema.getField("F920").schema(); + this.f9210 = readerSchema.getField("F921").schema(); + this.f9220 = readerSchema.getField("F922").schema(); + this.f9230 = readerSchema.getField("F923").schema(); + this.f9240 = readerSchema.getField("F924").schema(); + this.f9250 = readerSchema.getField("F925").schema(); + this.f9260 = readerSchema.getField("F926").schema(); + this.f9270 = readerSchema.getField("F927").schema(); + this.f9280 = readerSchema.getField("F928").schema(); + this.f9290 = readerSchema.getField("F929").schema(); + this.f9300 = readerSchema.getField("F930").schema(); + this.f9310 = readerSchema.getField("F931").schema(); + this.f9320 = readerSchema.getField("F932").schema(); + this.f9330 = readerSchema.getField("F933").schema(); + this.f9340 = readerSchema.getField("F934").schema(); + this.f9350 = readerSchema.getField("F935").schema(); + this.f9360 = readerSchema.getField("F936").schema(); + this.f9370 = readerSchema.getField("F937").schema(); + this.f9380 = readerSchema.getField("F938").schema(); + this.f9390 = readerSchema.getField("F939").schema(); + this.f9400 = readerSchema.getField("F940").schema(); + this.f9410 = readerSchema.getField("F941").schema(); + this.f9420 = readerSchema.getField("F942").schema(); + this.f9430 = readerSchema.getField("F943").schema(); + this.f9440 = readerSchema.getField("F944").schema(); + this.f9450 = readerSchema.getField("F945").schema(); + this.f9460 = readerSchema.getField("F946").schema(); + this.f9470 = readerSchema.getField("F947").schema(); + this.f9480 = readerSchema.getField("F948").schema(); + this.f9490 = readerSchema.getField("F949").schema(); + this.f9500 = readerSchema.getField("F950").schema(); + this.f9510 = readerSchema.getField("F951").schema(); + this.f9520 = readerSchema.getField("F952").schema(); + this.f9530 = readerSchema.getField("F953").schema(); + this.f9540 = readerSchema.getField("F954").schema(); + this.f9550 = readerSchema.getField("F955").schema(); + this.f9560 = readerSchema.getField("F956").schema(); + this.f9570 = readerSchema.getField("F957").schema(); + this.f9580 = readerSchema.getField("F958").schema(); + this.f9590 = readerSchema.getField("F959").schema(); + this.f9600 = readerSchema.getField("F960").schema(); + this.f9610 = readerSchema.getField("F961").schema(); + this.f9620 = readerSchema.getField("F962").schema(); + this.f9630 = readerSchema.getField("F963").schema(); + this.f9640 = readerSchema.getField("F964").schema(); + this.f9650 = readerSchema.getField("F965").schema(); + this.f9660 = readerSchema.getField("F966").schema(); + this.f9670 = readerSchema.getField("F967").schema(); + this.f9680 = readerSchema.getField("F968").schema(); + this.f9690 = readerSchema.getField("F969").schema(); + this.f9700 = readerSchema.getField("F970").schema(); + this.f9710 = readerSchema.getField("F971").schema(); + this.f9720 = readerSchema.getField("F972").schema(); + this.f9730 = readerSchema.getField("F973").schema(); + this.f9740 = readerSchema.getField("F974").schema(); + this.f9750 = readerSchema.getField("F975").schema(); + this.f9760 = readerSchema.getField("F976").schema(); + this.f9770 = readerSchema.getField("F977").schema(); + this.f9780 = readerSchema.getField("F978").schema(); + this.f9790 = readerSchema.getField("F979").schema(); + this.f9800 = readerSchema.getField("F980").schema(); + this.f9810 = readerSchema.getField("F981").schema(); + this.f9820 = readerSchema.getField("F982").schema(); + this.f9830 = readerSchema.getField("F983").schema(); + this.f9840 = readerSchema.getField("F984").schema(); + this.f9850 = readerSchema.getField("F985").schema(); + this.f9860 = readerSchema.getField("F986").schema(); + this.f9870 = readerSchema.getField("F987").schema(); + this.f9880 = readerSchema.getField("F988").schema(); + this.f9890 = readerSchema.getField("F989").schema(); + this.f9900 = readerSchema.getField("F990").schema(); + this.f9910 = readerSchema.getField("F991").schema(); + this.f9920 = readerSchema.getField("F992").schema(); + this.f9930 = readerSchema.getField("F993").schema(); + this.f9940 = readerSchema.getField("F994").schema(); + this.f9950 = readerSchema.getField("F995").schema(); + this.f9960 = readerSchema.getField("F996").schema(); + this.f9970 = readerSchema.getField("F997").schema(); + this.f9980 = readerSchema.getField("F998").schema(); + this.f9990 = readerSchema.getField("F999").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'F0': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499((FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(1, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'F1': "+ unionIndex1)); + } + } + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(2, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence2; + Object oldString2 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(2); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(2, charSequence2); + } else { + throw new RuntimeException(("Illegal union index for 'F2': "+ unionIndex2)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(3, null); + } else { + if (unionIndex3 == 1) { + Utf8 charSequence3; + Object oldString3 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(3); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(3, charSequence3); + } else { + throw new RuntimeException(("Illegal union index for 'F3': "+ unionIndex3)); + } + } + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(4, null); + } else { + if (unionIndex4 == 1) { + Utf8 charSequence4; + Object oldString4 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(4); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(4, charSequence4); + } else { + throw new RuntimeException(("Illegal union index for 'F4': "+ unionIndex4)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(5, null); + } else { + if (unionIndex5 == 1) { + Utf8 charSequence5; + Object oldString5 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(5); + if (oldString5 instanceof Utf8) { + charSequence5 = (decoder).readString(((Utf8) oldString5)); + } else { + charSequence5 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(5, charSequence5); + } else { + throw new RuntimeException(("Illegal union index for 'F5': "+ unionIndex5)); + } + } + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(6, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence6; + Object oldString6 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(6); + if (oldString6 instanceof Utf8) { + charSequence6 = (decoder).readString(((Utf8) oldString6)); + } else { + charSequence6 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(6, charSequence6); + } else { + throw new RuntimeException(("Illegal union index for 'F6': "+ unionIndex6)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(7, null); + } else { + if (unionIndex7 == 1) { + Utf8 charSequence7; + Object oldString7 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(7); + if (oldString7 instanceof Utf8) { + charSequence7 = (decoder).readString(((Utf8) oldString7)); + } else { + charSequence7 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(7, charSequence7); + } else { + throw new RuntimeException(("Illegal union index for 'F7': "+ unionIndex7)); + } + } + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(8, null); + } else { + if (unionIndex8 == 1) { + Utf8 charSequence8; + Object oldString8 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(8); + if (oldString8 instanceof Utf8) { + charSequence8 = (decoder).readString(((Utf8) oldString8)); + } else { + charSequence8 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(8, charSequence8); + } else { + throw new RuntimeException(("Illegal union index for 'F8': "+ unionIndex8)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex9 = (decoder.readIndex()); + if (unionIndex9 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(9, null); + } else { + if (unionIndex9 == 1) { + Utf8 charSequence9; + Object oldString9 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(9); + if (oldString9 instanceof Utf8) { + charSequence9 = (decoder).readString(((Utf8) oldString9)); + } else { + charSequence9 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(9, charSequence9); + } else { + throw new RuntimeException(("Illegal union index for 'F9': "+ unionIndex9)); + } + } + int unionIndex10 = (decoder.readIndex()); + if (unionIndex10 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(10, null); + } else { + if (unionIndex10 == 1) { + Utf8 charSequence10; + Object oldString10 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(10); + if (oldString10 instanceof Utf8) { + charSequence10 = (decoder).readString(((Utf8) oldString10)); + } else { + charSequence10 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(10, charSequence10); + } else { + throw new RuntimeException(("Illegal union index for 'F10': "+ unionIndex10)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex11 = (decoder.readIndex()); + if (unionIndex11 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(11, null); + } else { + if (unionIndex11 == 1) { + Utf8 charSequence11; + Object oldString11 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(11); + if (oldString11 instanceof Utf8) { + charSequence11 = (decoder).readString(((Utf8) oldString11)); + } else { + charSequence11 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(11, charSequence11); + } else { + throw new RuntimeException(("Illegal union index for 'F11': "+ unionIndex11)); + } + } + int unionIndex12 = (decoder.readIndex()); + if (unionIndex12 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(12, null); + } else { + if (unionIndex12 == 1) { + Utf8 charSequence12; + Object oldString12 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(12); + if (oldString12 instanceof Utf8) { + charSequence12 = (decoder).readString(((Utf8) oldString12)); + } else { + charSequence12 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(12, charSequence12); + } else { + throw new RuntimeException(("Illegal union index for 'F12': "+ unionIndex12)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex13 = (decoder.readIndex()); + if (unionIndex13 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(13, null); + } else { + if (unionIndex13 == 1) { + Utf8 charSequence13; + Object oldString13 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(13); + if (oldString13 instanceof Utf8) { + charSequence13 = (decoder).readString(((Utf8) oldString13)); + } else { + charSequence13 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(13, charSequence13); + } else { + throw new RuntimeException(("Illegal union index for 'F13': "+ unionIndex13)); + } + } + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(14, null); + } else { + if (unionIndex14 == 1) { + Utf8 charSequence14; + Object oldString14 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(14); + if (oldString14 instanceof Utf8) { + charSequence14 = (decoder).readString(((Utf8) oldString14)); + } else { + charSequence14 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(14, charSequence14); + } else { + throw new RuntimeException(("Illegal union index for 'F14': "+ unionIndex14)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema7(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(15, null); + } else { + if (unionIndex15 == 1) { + Utf8 charSequence15; + Object oldString15 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(15); + if (oldString15 instanceof Utf8) { + charSequence15 = (decoder).readString(((Utf8) oldString15)); + } else { + charSequence15 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(15, charSequence15); + } else { + throw new RuntimeException(("Illegal union index for 'F15': "+ unionIndex15)); + } + } + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(16, null); + } else { + if (unionIndex16 == 1) { + Utf8 charSequence16; + Object oldString16 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(16); + if (oldString16 instanceof Utf8) { + charSequence16 = (decoder).readString(((Utf8) oldString16)); + } else { + charSequence16 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(16, charSequence16); + } else { + throw new RuntimeException(("Illegal union index for 'F16': "+ unionIndex16)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema8(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex17 = (decoder.readIndex()); + if (unionIndex17 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(17, null); + } else { + if (unionIndex17 == 1) { + Utf8 charSequence17; + Object oldString17 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(17); + if (oldString17 instanceof Utf8) { + charSequence17 = (decoder).readString(((Utf8) oldString17)); + } else { + charSequence17 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(17, charSequence17); + } else { + throw new RuntimeException(("Illegal union index for 'F17': "+ unionIndex17)); + } + } + int unionIndex18 = (decoder.readIndex()); + if (unionIndex18 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(18, null); + } else { + if (unionIndex18 == 1) { + Utf8 charSequence18; + Object oldString18 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(18); + if (oldString18 instanceof Utf8) { + charSequence18 = (decoder).readString(((Utf8) oldString18)); + } else { + charSequence18 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(18, charSequence18); + } else { + throw new RuntimeException(("Illegal union index for 'F18': "+ unionIndex18)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema9(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex19 = (decoder.readIndex()); + if (unionIndex19 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(19, null); + } else { + if (unionIndex19 == 1) { + Utf8 charSequence19; + Object oldString19 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(19); + if (oldString19 instanceof Utf8) { + charSequence19 = (decoder).readString(((Utf8) oldString19)); + } else { + charSequence19 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(19, charSequence19); + } else { + throw new RuntimeException(("Illegal union index for 'F19': "+ unionIndex19)); + } + } + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(20, null); + } else { + if (unionIndex20 == 1) { + Utf8 charSequence20; + Object oldString20 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(20); + if (oldString20 instanceof Utf8) { + charSequence20 = (decoder).readString(((Utf8) oldString20)); + } else { + charSequence20 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(20, charSequence20); + } else { + throw new RuntimeException(("Illegal union index for 'F20': "+ unionIndex20)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema10(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(21, null); + } else { + if (unionIndex21 == 1) { + Utf8 charSequence21; + Object oldString21 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(21); + if (oldString21 instanceof Utf8) { + charSequence21 = (decoder).readString(((Utf8) oldString21)); + } else { + charSequence21 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(21, charSequence21); + } else { + throw new RuntimeException(("Illegal union index for 'F21': "+ unionIndex21)); + } + } + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(22, null); + } else { + if (unionIndex22 == 1) { + Utf8 charSequence22; + Object oldString22 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(22); + if (oldString22 instanceof Utf8) { + charSequence22 = (decoder).readString(((Utf8) oldString22)); + } else { + charSequence22 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(22, charSequence22); + } else { + throw new RuntimeException(("Illegal union index for 'F22': "+ unionIndex22)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema11(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(23, null); + } else { + if (unionIndex23 == 1) { + Utf8 charSequence23; + Object oldString23 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(23); + if (oldString23 instanceof Utf8) { + charSequence23 = (decoder).readString(((Utf8) oldString23)); + } else { + charSequence23 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(23, charSequence23); + } else { + throw new RuntimeException(("Illegal union index for 'F23': "+ unionIndex23)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(24, null); + } else { + if (unionIndex24 == 1) { + Utf8 charSequence24; + Object oldString24 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(24); + if (oldString24 instanceof Utf8) { + charSequence24 = (decoder).readString(((Utf8) oldString24)); + } else { + charSequence24 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(24, charSequence24); + } else { + throw new RuntimeException(("Illegal union index for 'F24': "+ unionIndex24)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema12(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(25, null); + } else { + if (unionIndex25 == 1) { + Utf8 charSequence25; + Object oldString25 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(25); + if (oldString25 instanceof Utf8) { + charSequence25 = (decoder).readString(((Utf8) oldString25)); + } else { + charSequence25 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(25, charSequence25); + } else { + throw new RuntimeException(("Illegal union index for 'F25': "+ unionIndex25)); + } + } + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(26, null); + } else { + if (unionIndex26 == 1) { + Utf8 charSequence26; + Object oldString26 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(26); + if (oldString26 instanceof Utf8) { + charSequence26 = (decoder).readString(((Utf8) oldString26)); + } else { + charSequence26 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(26, charSequence26); + } else { + throw new RuntimeException(("Illegal union index for 'F26': "+ unionIndex26)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema13(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex27 = (decoder.readIndex()); + if (unionIndex27 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(27, null); + } else { + if (unionIndex27 == 1) { + Utf8 charSequence27; + Object oldString27 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(27); + if (oldString27 instanceof Utf8) { + charSequence27 = (decoder).readString(((Utf8) oldString27)); + } else { + charSequence27 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(27, charSequence27); + } else { + throw new RuntimeException(("Illegal union index for 'F27': "+ unionIndex27)); + } + } + int unionIndex28 = (decoder.readIndex()); + if (unionIndex28 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(28, null); + } else { + if (unionIndex28 == 1) { + Utf8 charSequence28; + Object oldString28 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(28); + if (oldString28 instanceof Utf8) { + charSequence28 = (decoder).readString(((Utf8) oldString28)); + } else { + charSequence28 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(28, charSequence28); + } else { + throw new RuntimeException(("Illegal union index for 'F28': "+ unionIndex28)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema14(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex29 = (decoder.readIndex()); + if (unionIndex29 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(29, null); + } else { + if (unionIndex29 == 1) { + Utf8 charSequence29; + Object oldString29 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(29); + if (oldString29 instanceof Utf8) { + charSequence29 = (decoder).readString(((Utf8) oldString29)); + } else { + charSequence29 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(29, charSequence29); + } else { + throw new RuntimeException(("Illegal union index for 'F29': "+ unionIndex29)); + } + } + int unionIndex30 = (decoder.readIndex()); + if (unionIndex30 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(30, null); + } else { + if (unionIndex30 == 1) { + Utf8 charSequence30; + Object oldString30 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(30); + if (oldString30 instanceof Utf8) { + charSequence30 = (decoder).readString(((Utf8) oldString30)); + } else { + charSequence30 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(30, charSequence30); + } else { + throw new RuntimeException(("Illegal union index for 'F30': "+ unionIndex30)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema15(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex31 = (decoder.readIndex()); + if (unionIndex31 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(31, null); + } else { + if (unionIndex31 == 1) { + Utf8 charSequence31; + Object oldString31 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(31); + if (oldString31 instanceof Utf8) { + charSequence31 = (decoder).readString(((Utf8) oldString31)); + } else { + charSequence31 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(31, charSequence31); + } else { + throw new RuntimeException(("Illegal union index for 'F31': "+ unionIndex31)); + } + } + int unionIndex32 = (decoder.readIndex()); + if (unionIndex32 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(32, null); + } else { + if (unionIndex32 == 1) { + Utf8 charSequence32; + Object oldString32 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(32); + if (oldString32 instanceof Utf8) { + charSequence32 = (decoder).readString(((Utf8) oldString32)); + } else { + charSequence32 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(32, charSequence32); + } else { + throw new RuntimeException(("Illegal union index for 'F32': "+ unionIndex32)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema16(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex33 = (decoder.readIndex()); + if (unionIndex33 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(33, null); + } else { + if (unionIndex33 == 1) { + Utf8 charSequence33; + Object oldString33 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(33); + if (oldString33 instanceof Utf8) { + charSequence33 = (decoder).readString(((Utf8) oldString33)); + } else { + charSequence33 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(33, charSequence33); + } else { + throw new RuntimeException(("Illegal union index for 'F33': "+ unionIndex33)); + } + } + int unionIndex34 = (decoder.readIndex()); + if (unionIndex34 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(34, null); + } else { + if (unionIndex34 == 1) { + Utf8 charSequence34; + Object oldString34 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(34); + if (oldString34 instanceof Utf8) { + charSequence34 = (decoder).readString(((Utf8) oldString34)); + } else { + charSequence34 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(34, charSequence34); + } else { + throw new RuntimeException(("Illegal union index for 'F34': "+ unionIndex34)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema17(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex35 = (decoder.readIndex()); + if (unionIndex35 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(35, null); + } else { + if (unionIndex35 == 1) { + Utf8 charSequence35; + Object oldString35 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(35); + if (oldString35 instanceof Utf8) { + charSequence35 = (decoder).readString(((Utf8) oldString35)); + } else { + charSequence35 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(35, charSequence35); + } else { + throw new RuntimeException(("Illegal union index for 'F35': "+ unionIndex35)); + } + } + int unionIndex36 = (decoder.readIndex()); + if (unionIndex36 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(36, null); + } else { + if (unionIndex36 == 1) { + Utf8 charSequence36; + Object oldString36 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(36); + if (oldString36 instanceof Utf8) { + charSequence36 = (decoder).readString(((Utf8) oldString36)); + } else { + charSequence36 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(36, charSequence36); + } else { + throw new RuntimeException(("Illegal union index for 'F36': "+ unionIndex36)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema18(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex37 = (decoder.readIndex()); + if (unionIndex37 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(37, null); + } else { + if (unionIndex37 == 1) { + Utf8 charSequence37; + Object oldString37 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(37); + if (oldString37 instanceof Utf8) { + charSequence37 = (decoder).readString(((Utf8) oldString37)); + } else { + charSequence37 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(37, charSequence37); + } else { + throw new RuntimeException(("Illegal union index for 'F37': "+ unionIndex37)); + } + } + int unionIndex38 = (decoder.readIndex()); + if (unionIndex38 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(38, null); + } else { + if (unionIndex38 == 1) { + Utf8 charSequence38; + Object oldString38 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(38); + if (oldString38 instanceof Utf8) { + charSequence38 = (decoder).readString(((Utf8) oldString38)); + } else { + charSequence38 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(38, charSequence38); + } else { + throw new RuntimeException(("Illegal union index for 'F38': "+ unionIndex38)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema19(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex39 = (decoder.readIndex()); + if (unionIndex39 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(39, null); + } else { + if (unionIndex39 == 1) { + Utf8 charSequence39; + Object oldString39 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(39); + if (oldString39 instanceof Utf8) { + charSequence39 = (decoder).readString(((Utf8) oldString39)); + } else { + charSequence39 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(39, charSequence39); + } else { + throw new RuntimeException(("Illegal union index for 'F39': "+ unionIndex39)); + } + } + int unionIndex40 = (decoder.readIndex()); + if (unionIndex40 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(40, null); + } else { + if (unionIndex40 == 1) { + Utf8 charSequence40; + Object oldString40 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(40); + if (oldString40 instanceof Utf8) { + charSequence40 = (decoder).readString(((Utf8) oldString40)); + } else { + charSequence40 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(40, charSequence40); + } else { + throw new RuntimeException(("Illegal union index for 'F40': "+ unionIndex40)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema20(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex41 = (decoder.readIndex()); + if (unionIndex41 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(41, null); + } else { + if (unionIndex41 == 1) { + Utf8 charSequence41; + Object oldString41 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(41); + if (oldString41 instanceof Utf8) { + charSequence41 = (decoder).readString(((Utf8) oldString41)); + } else { + charSequence41 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(41, charSequence41); + } else { + throw new RuntimeException(("Illegal union index for 'F41': "+ unionIndex41)); + } + } + int unionIndex42 = (decoder.readIndex()); + if (unionIndex42 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(42, null); + } else { + if (unionIndex42 == 1) { + Utf8 charSequence42; + Object oldString42 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(42); + if (oldString42 instanceof Utf8) { + charSequence42 = (decoder).readString(((Utf8) oldString42)); + } else { + charSequence42 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(42, charSequence42); + } else { + throw new RuntimeException(("Illegal union index for 'F42': "+ unionIndex42)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema21(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex43 = (decoder.readIndex()); + if (unionIndex43 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(43, null); + } else { + if (unionIndex43 == 1) { + Utf8 charSequence43; + Object oldString43 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(43); + if (oldString43 instanceof Utf8) { + charSequence43 = (decoder).readString(((Utf8) oldString43)); + } else { + charSequence43 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(43, charSequence43); + } else { + throw new RuntimeException(("Illegal union index for 'F43': "+ unionIndex43)); + } + } + int unionIndex44 = (decoder.readIndex()); + if (unionIndex44 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(44, null); + } else { + if (unionIndex44 == 1) { + Utf8 charSequence44; + Object oldString44 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(44); + if (oldString44 instanceof Utf8) { + charSequence44 = (decoder).readString(((Utf8) oldString44)); + } else { + charSequence44 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(44, charSequence44); + } else { + throw new RuntimeException(("Illegal union index for 'F44': "+ unionIndex44)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema22(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex45 = (decoder.readIndex()); + if (unionIndex45 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(45, null); + } else { + if (unionIndex45 == 1) { + Utf8 charSequence45; + Object oldString45 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(45); + if (oldString45 instanceof Utf8) { + charSequence45 = (decoder).readString(((Utf8) oldString45)); + } else { + charSequence45 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(45, charSequence45); + } else { + throw new RuntimeException(("Illegal union index for 'F45': "+ unionIndex45)); + } + } + int unionIndex46 = (decoder.readIndex()); + if (unionIndex46 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(46, null); + } else { + if (unionIndex46 == 1) { + Utf8 charSequence46; + Object oldString46 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(46); + if (oldString46 instanceof Utf8) { + charSequence46 = (decoder).readString(((Utf8) oldString46)); + } else { + charSequence46 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(46, charSequence46); + } else { + throw new RuntimeException(("Illegal union index for 'F46': "+ unionIndex46)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema23(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex47 = (decoder.readIndex()); + if (unionIndex47 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(47, null); + } else { + if (unionIndex47 == 1) { + Utf8 charSequence47; + Object oldString47 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(47); + if (oldString47 instanceof Utf8) { + charSequence47 = (decoder).readString(((Utf8) oldString47)); + } else { + charSequence47 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(47, charSequence47); + } else { + throw new RuntimeException(("Illegal union index for 'F47': "+ unionIndex47)); + } + } + int unionIndex48 = (decoder.readIndex()); + if (unionIndex48 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(48, null); + } else { + if (unionIndex48 == 1) { + Utf8 charSequence48; + Object oldString48 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(48); + if (oldString48 instanceof Utf8) { + charSequence48 = (decoder).readString(((Utf8) oldString48)); + } else { + charSequence48 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(48, charSequence48); + } else { + throw new RuntimeException(("Illegal union index for 'F48': "+ unionIndex48)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema24(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex49 = (decoder.readIndex()); + if (unionIndex49 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(49, null); + } else { + if (unionIndex49 == 1) { + Utf8 charSequence49; + Object oldString49 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(49); + if (oldString49 instanceof Utf8) { + charSequence49 = (decoder).readString(((Utf8) oldString49)); + } else { + charSequence49 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(49, charSequence49); + } else { + throw new RuntimeException(("Illegal union index for 'F49': "+ unionIndex49)); + } + } + int unionIndex50 = (decoder.readIndex()); + if (unionIndex50 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(50, null); + } else { + if (unionIndex50 == 1) { + Utf8 charSequence50; + Object oldString50 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(50); + if (oldString50 instanceof Utf8) { + charSequence50 = (decoder).readString(((Utf8) oldString50)); + } else { + charSequence50 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(50, charSequence50); + } else { + throw new RuntimeException(("Illegal union index for 'F50': "+ unionIndex50)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema25(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex51 = (decoder.readIndex()); + if (unionIndex51 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(51, null); + } else { + if (unionIndex51 == 1) { + Utf8 charSequence51; + Object oldString51 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(51); + if (oldString51 instanceof Utf8) { + charSequence51 = (decoder).readString(((Utf8) oldString51)); + } else { + charSequence51 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(51, charSequence51); + } else { + throw new RuntimeException(("Illegal union index for 'F51': "+ unionIndex51)); + } + } + int unionIndex52 = (decoder.readIndex()); + if (unionIndex52 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(52, null); + } else { + if (unionIndex52 == 1) { + Utf8 charSequence52; + Object oldString52 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(52); + if (oldString52 instanceof Utf8) { + charSequence52 = (decoder).readString(((Utf8) oldString52)); + } else { + charSequence52 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(52, charSequence52); + } else { + throw new RuntimeException(("Illegal union index for 'F52': "+ unionIndex52)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema26(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex53 = (decoder.readIndex()); + if (unionIndex53 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(53, null); + } else { + if (unionIndex53 == 1) { + Utf8 charSequence53; + Object oldString53 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(53); + if (oldString53 instanceof Utf8) { + charSequence53 = (decoder).readString(((Utf8) oldString53)); + } else { + charSequence53 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(53, charSequence53); + } else { + throw new RuntimeException(("Illegal union index for 'F53': "+ unionIndex53)); + } + } + int unionIndex54 = (decoder.readIndex()); + if (unionIndex54 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(54, null); + } else { + if (unionIndex54 == 1) { + Utf8 charSequence54; + Object oldString54 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(54); + if (oldString54 instanceof Utf8) { + charSequence54 = (decoder).readString(((Utf8) oldString54)); + } else { + charSequence54 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(54, charSequence54); + } else { + throw new RuntimeException(("Illegal union index for 'F54': "+ unionIndex54)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema27(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex55 = (decoder.readIndex()); + if (unionIndex55 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(55, null); + } else { + if (unionIndex55 == 1) { + Utf8 charSequence55; + Object oldString55 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(55); + if (oldString55 instanceof Utf8) { + charSequence55 = (decoder).readString(((Utf8) oldString55)); + } else { + charSequence55 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(55, charSequence55); + } else { + throw new RuntimeException(("Illegal union index for 'F55': "+ unionIndex55)); + } + } + int unionIndex56 = (decoder.readIndex()); + if (unionIndex56 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(56, null); + } else { + if (unionIndex56 == 1) { + Utf8 charSequence56; + Object oldString56 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(56); + if (oldString56 instanceof Utf8) { + charSequence56 = (decoder).readString(((Utf8) oldString56)); + } else { + charSequence56 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(56, charSequence56); + } else { + throw new RuntimeException(("Illegal union index for 'F56': "+ unionIndex56)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema28(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex57 = (decoder.readIndex()); + if (unionIndex57 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(57, null); + } else { + if (unionIndex57 == 1) { + Utf8 charSequence57; + Object oldString57 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(57); + if (oldString57 instanceof Utf8) { + charSequence57 = (decoder).readString(((Utf8) oldString57)); + } else { + charSequence57 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(57, charSequence57); + } else { + throw new RuntimeException(("Illegal union index for 'F57': "+ unionIndex57)); + } + } + int unionIndex58 = (decoder.readIndex()); + if (unionIndex58 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(58, null); + } else { + if (unionIndex58 == 1) { + Utf8 charSequence58; + Object oldString58 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(58); + if (oldString58 instanceof Utf8) { + charSequence58 = (decoder).readString(((Utf8) oldString58)); + } else { + charSequence58 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(58, charSequence58); + } else { + throw new RuntimeException(("Illegal union index for 'F58': "+ unionIndex58)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema29(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex59 = (decoder.readIndex()); + if (unionIndex59 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(59, null); + } else { + if (unionIndex59 == 1) { + Utf8 charSequence59; + Object oldString59 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(59); + if (oldString59 instanceof Utf8) { + charSequence59 = (decoder).readString(((Utf8) oldString59)); + } else { + charSequence59 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(59, charSequence59); + } else { + throw new RuntimeException(("Illegal union index for 'F59': "+ unionIndex59)); + } + } + int unionIndex60 = (decoder.readIndex()); + if (unionIndex60 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(60, null); + } else { + if (unionIndex60 == 1) { + Utf8 charSequence60; + Object oldString60 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(60); + if (oldString60 instanceof Utf8) { + charSequence60 = (decoder).readString(((Utf8) oldString60)); + } else { + charSequence60 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(60, charSequence60); + } else { + throw new RuntimeException(("Illegal union index for 'F60': "+ unionIndex60)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema30(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex61 = (decoder.readIndex()); + if (unionIndex61 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(61, null); + } else { + if (unionIndex61 == 1) { + Utf8 charSequence61; + Object oldString61 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(61); + if (oldString61 instanceof Utf8) { + charSequence61 = (decoder).readString(((Utf8) oldString61)); + } else { + charSequence61 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(61, charSequence61); + } else { + throw new RuntimeException(("Illegal union index for 'F61': "+ unionIndex61)); + } + } + int unionIndex62 = (decoder.readIndex()); + if (unionIndex62 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(62, null); + } else { + if (unionIndex62 == 1) { + Utf8 charSequence62; + Object oldString62 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(62); + if (oldString62 instanceof Utf8) { + charSequence62 = (decoder).readString(((Utf8) oldString62)); + } else { + charSequence62 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(62, charSequence62); + } else { + throw new RuntimeException(("Illegal union index for 'F62': "+ unionIndex62)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema31(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex63 = (decoder.readIndex()); + if (unionIndex63 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(63, null); + } else { + if (unionIndex63 == 1) { + Utf8 charSequence63; + Object oldString63 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(63); + if (oldString63 instanceof Utf8) { + charSequence63 = (decoder).readString(((Utf8) oldString63)); + } else { + charSequence63 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(63, charSequence63); + } else { + throw new RuntimeException(("Illegal union index for 'F63': "+ unionIndex63)); + } + } + int unionIndex64 = (decoder.readIndex()); + if (unionIndex64 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(64, null); + } else { + if (unionIndex64 == 1) { + Utf8 charSequence64; + Object oldString64 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(64); + if (oldString64 instanceof Utf8) { + charSequence64 = (decoder).readString(((Utf8) oldString64)); + } else { + charSequence64 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(64, charSequence64); + } else { + throw new RuntimeException(("Illegal union index for 'F64': "+ unionIndex64)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema32(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex65 = (decoder.readIndex()); + if (unionIndex65 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(65, null); + } else { + if (unionIndex65 == 1) { + Utf8 charSequence65; + Object oldString65 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(65); + if (oldString65 instanceof Utf8) { + charSequence65 = (decoder).readString(((Utf8) oldString65)); + } else { + charSequence65 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(65, charSequence65); + } else { + throw new RuntimeException(("Illegal union index for 'F65': "+ unionIndex65)); + } + } + int unionIndex66 = (decoder.readIndex()); + if (unionIndex66 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(66, null); + } else { + if (unionIndex66 == 1) { + Utf8 charSequence66; + Object oldString66 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(66); + if (oldString66 instanceof Utf8) { + charSequence66 = (decoder).readString(((Utf8) oldString66)); + } else { + charSequence66 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(66, charSequence66); + } else { + throw new RuntimeException(("Illegal union index for 'F66': "+ unionIndex66)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema33(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex67 = (decoder.readIndex()); + if (unionIndex67 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(67, null); + } else { + if (unionIndex67 == 1) { + Utf8 charSequence67; + Object oldString67 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(67); + if (oldString67 instanceof Utf8) { + charSequence67 = (decoder).readString(((Utf8) oldString67)); + } else { + charSequence67 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(67, charSequence67); + } else { + throw new RuntimeException(("Illegal union index for 'F67': "+ unionIndex67)); + } + } + int unionIndex68 = (decoder.readIndex()); + if (unionIndex68 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(68, null); + } else { + if (unionIndex68 == 1) { + Utf8 charSequence68; + Object oldString68 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(68); + if (oldString68 instanceof Utf8) { + charSequence68 = (decoder).readString(((Utf8) oldString68)); + } else { + charSequence68 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(68, charSequence68); + } else { + throw new RuntimeException(("Illegal union index for 'F68': "+ unionIndex68)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema34(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex69 = (decoder.readIndex()); + if (unionIndex69 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(69, null); + } else { + if (unionIndex69 == 1) { + Utf8 charSequence69; + Object oldString69 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(69); + if (oldString69 instanceof Utf8) { + charSequence69 = (decoder).readString(((Utf8) oldString69)); + } else { + charSequence69 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(69, charSequence69); + } else { + throw new RuntimeException(("Illegal union index for 'F69': "+ unionIndex69)); + } + } + int unionIndex70 = (decoder.readIndex()); + if (unionIndex70 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(70, null); + } else { + if (unionIndex70 == 1) { + Utf8 charSequence70; + Object oldString70 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(70); + if (oldString70 instanceof Utf8) { + charSequence70 = (decoder).readString(((Utf8) oldString70)); + } else { + charSequence70 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(70, charSequence70); + } else { + throw new RuntimeException(("Illegal union index for 'F70': "+ unionIndex70)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema35(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex71 = (decoder.readIndex()); + if (unionIndex71 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(71, null); + } else { + if (unionIndex71 == 1) { + Utf8 charSequence71; + Object oldString71 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(71); + if (oldString71 instanceof Utf8) { + charSequence71 = (decoder).readString(((Utf8) oldString71)); + } else { + charSequence71 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(71, charSequence71); + } else { + throw new RuntimeException(("Illegal union index for 'F71': "+ unionIndex71)); + } + } + int unionIndex72 = (decoder.readIndex()); + if (unionIndex72 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(72, null); + } else { + if (unionIndex72 == 1) { + Utf8 charSequence72; + Object oldString72 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(72); + if (oldString72 instanceof Utf8) { + charSequence72 = (decoder).readString(((Utf8) oldString72)); + } else { + charSequence72 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(72, charSequence72); + } else { + throw new RuntimeException(("Illegal union index for 'F72': "+ unionIndex72)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema36(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex73 = (decoder.readIndex()); + if (unionIndex73 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(73, null); + } else { + if (unionIndex73 == 1) { + Utf8 charSequence73; + Object oldString73 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(73); + if (oldString73 instanceof Utf8) { + charSequence73 = (decoder).readString(((Utf8) oldString73)); + } else { + charSequence73 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(73, charSequence73); + } else { + throw new RuntimeException(("Illegal union index for 'F73': "+ unionIndex73)); + } + } + int unionIndex74 = (decoder.readIndex()); + if (unionIndex74 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(74, null); + } else { + if (unionIndex74 == 1) { + Utf8 charSequence74; + Object oldString74 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(74); + if (oldString74 instanceof Utf8) { + charSequence74 = (decoder).readString(((Utf8) oldString74)); + } else { + charSequence74 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(74, charSequence74); + } else { + throw new RuntimeException(("Illegal union index for 'F74': "+ unionIndex74)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema37(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex75 = (decoder.readIndex()); + if (unionIndex75 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(75, null); + } else { + if (unionIndex75 == 1) { + Utf8 charSequence75; + Object oldString75 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(75); + if (oldString75 instanceof Utf8) { + charSequence75 = (decoder).readString(((Utf8) oldString75)); + } else { + charSequence75 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(75, charSequence75); + } else { + throw new RuntimeException(("Illegal union index for 'F75': "+ unionIndex75)); + } + } + int unionIndex76 = (decoder.readIndex()); + if (unionIndex76 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(76, null); + } else { + if (unionIndex76 == 1) { + Utf8 charSequence76; + Object oldString76 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(76); + if (oldString76 instanceof Utf8) { + charSequence76 = (decoder).readString(((Utf8) oldString76)); + } else { + charSequence76 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(76, charSequence76); + } else { + throw new RuntimeException(("Illegal union index for 'F76': "+ unionIndex76)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema38(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex77 = (decoder.readIndex()); + if (unionIndex77 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(77, null); + } else { + if (unionIndex77 == 1) { + Utf8 charSequence77; + Object oldString77 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(77); + if (oldString77 instanceof Utf8) { + charSequence77 = (decoder).readString(((Utf8) oldString77)); + } else { + charSequence77 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(77, charSequence77); + } else { + throw new RuntimeException(("Illegal union index for 'F77': "+ unionIndex77)); + } + } + int unionIndex78 = (decoder.readIndex()); + if (unionIndex78 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(78, null); + } else { + if (unionIndex78 == 1) { + Utf8 charSequence78; + Object oldString78 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(78); + if (oldString78 instanceof Utf8) { + charSequence78 = (decoder).readString(((Utf8) oldString78)); + } else { + charSequence78 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(78, charSequence78); + } else { + throw new RuntimeException(("Illegal union index for 'F78': "+ unionIndex78)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema39(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex79 = (decoder.readIndex()); + if (unionIndex79 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(79, null); + } else { + if (unionIndex79 == 1) { + Utf8 charSequence79; + Object oldString79 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(79); + if (oldString79 instanceof Utf8) { + charSequence79 = (decoder).readString(((Utf8) oldString79)); + } else { + charSequence79 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(79, charSequence79); + } else { + throw new RuntimeException(("Illegal union index for 'F79': "+ unionIndex79)); + } + } + int unionIndex80 = (decoder.readIndex()); + if (unionIndex80 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(80, null); + } else { + if (unionIndex80 == 1) { + Utf8 charSequence80; + Object oldString80 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(80); + if (oldString80 instanceof Utf8) { + charSequence80 = (decoder).readString(((Utf8) oldString80)); + } else { + charSequence80 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(80, charSequence80); + } else { + throw new RuntimeException(("Illegal union index for 'F80': "+ unionIndex80)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema40(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex81 = (decoder.readIndex()); + if (unionIndex81 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(81, null); + } else { + if (unionIndex81 == 1) { + Utf8 charSequence81; + Object oldString81 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(81); + if (oldString81 instanceof Utf8) { + charSequence81 = (decoder).readString(((Utf8) oldString81)); + } else { + charSequence81 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(81, charSequence81); + } else { + throw new RuntimeException(("Illegal union index for 'F81': "+ unionIndex81)); + } + } + int unionIndex82 = (decoder.readIndex()); + if (unionIndex82 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(82, null); + } else { + if (unionIndex82 == 1) { + Utf8 charSequence82; + Object oldString82 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(82); + if (oldString82 instanceof Utf8) { + charSequence82 = (decoder).readString(((Utf8) oldString82)); + } else { + charSequence82 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(82, charSequence82); + } else { + throw new RuntimeException(("Illegal union index for 'F82': "+ unionIndex82)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema41(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex83 = (decoder.readIndex()); + if (unionIndex83 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(83, null); + } else { + if (unionIndex83 == 1) { + Utf8 charSequence83; + Object oldString83 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(83); + if (oldString83 instanceof Utf8) { + charSequence83 = (decoder).readString(((Utf8) oldString83)); + } else { + charSequence83 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(83, charSequence83); + } else { + throw new RuntimeException(("Illegal union index for 'F83': "+ unionIndex83)); + } + } + int unionIndex84 = (decoder.readIndex()); + if (unionIndex84 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(84, null); + } else { + if (unionIndex84 == 1) { + Utf8 charSequence84; + Object oldString84 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(84); + if (oldString84 instanceof Utf8) { + charSequence84 = (decoder).readString(((Utf8) oldString84)); + } else { + charSequence84 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(84, charSequence84); + } else { + throw new RuntimeException(("Illegal union index for 'F84': "+ unionIndex84)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema42(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex85 = (decoder.readIndex()); + if (unionIndex85 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(85, null); + } else { + if (unionIndex85 == 1) { + Utf8 charSequence85; + Object oldString85 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(85); + if (oldString85 instanceof Utf8) { + charSequence85 = (decoder).readString(((Utf8) oldString85)); + } else { + charSequence85 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(85, charSequence85); + } else { + throw new RuntimeException(("Illegal union index for 'F85': "+ unionIndex85)); + } + } + int unionIndex86 = (decoder.readIndex()); + if (unionIndex86 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(86, null); + } else { + if (unionIndex86 == 1) { + Utf8 charSequence86; + Object oldString86 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(86); + if (oldString86 instanceof Utf8) { + charSequence86 = (decoder).readString(((Utf8) oldString86)); + } else { + charSequence86 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(86, charSequence86); + } else { + throw new RuntimeException(("Illegal union index for 'F86': "+ unionIndex86)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema43(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex87 = (decoder.readIndex()); + if (unionIndex87 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(87, null); + } else { + if (unionIndex87 == 1) { + Utf8 charSequence87; + Object oldString87 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(87); + if (oldString87 instanceof Utf8) { + charSequence87 = (decoder).readString(((Utf8) oldString87)); + } else { + charSequence87 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(87, charSequence87); + } else { + throw new RuntimeException(("Illegal union index for 'F87': "+ unionIndex87)); + } + } + int unionIndex88 = (decoder.readIndex()); + if (unionIndex88 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(88, null); + } else { + if (unionIndex88 == 1) { + Utf8 charSequence88; + Object oldString88 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(88); + if (oldString88 instanceof Utf8) { + charSequence88 = (decoder).readString(((Utf8) oldString88)); + } else { + charSequence88 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(88, charSequence88); + } else { + throw new RuntimeException(("Illegal union index for 'F88': "+ unionIndex88)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema44(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex89 = (decoder.readIndex()); + if (unionIndex89 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(89, null); + } else { + if (unionIndex89 == 1) { + Utf8 charSequence89; + Object oldString89 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(89); + if (oldString89 instanceof Utf8) { + charSequence89 = (decoder).readString(((Utf8) oldString89)); + } else { + charSequence89 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(89, charSequence89); + } else { + throw new RuntimeException(("Illegal union index for 'F89': "+ unionIndex89)); + } + } + int unionIndex90 = (decoder.readIndex()); + if (unionIndex90 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(90, null); + } else { + if (unionIndex90 == 1) { + Utf8 charSequence90; + Object oldString90 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(90); + if (oldString90 instanceof Utf8) { + charSequence90 = (decoder).readString(((Utf8) oldString90)); + } else { + charSequence90 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(90, charSequence90); + } else { + throw new RuntimeException(("Illegal union index for 'F90': "+ unionIndex90)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema45(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex91 = (decoder.readIndex()); + if (unionIndex91 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(91, null); + } else { + if (unionIndex91 == 1) { + Utf8 charSequence91; + Object oldString91 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(91); + if (oldString91 instanceof Utf8) { + charSequence91 = (decoder).readString(((Utf8) oldString91)); + } else { + charSequence91 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(91, charSequence91); + } else { + throw new RuntimeException(("Illegal union index for 'F91': "+ unionIndex91)); + } + } + int unionIndex92 = (decoder.readIndex()); + if (unionIndex92 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(92, null); + } else { + if (unionIndex92 == 1) { + Utf8 charSequence92; + Object oldString92 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(92); + if (oldString92 instanceof Utf8) { + charSequence92 = (decoder).readString(((Utf8) oldString92)); + } else { + charSequence92 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(92, charSequence92); + } else { + throw new RuntimeException(("Illegal union index for 'F92': "+ unionIndex92)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema46(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex93 = (decoder.readIndex()); + if (unionIndex93 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(93, null); + } else { + if (unionIndex93 == 1) { + Utf8 charSequence93; + Object oldString93 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(93); + if (oldString93 instanceof Utf8) { + charSequence93 = (decoder).readString(((Utf8) oldString93)); + } else { + charSequence93 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(93, charSequence93); + } else { + throw new RuntimeException(("Illegal union index for 'F93': "+ unionIndex93)); + } + } + int unionIndex94 = (decoder.readIndex()); + if (unionIndex94 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(94, null); + } else { + if (unionIndex94 == 1) { + Utf8 charSequence94; + Object oldString94 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(94); + if (oldString94 instanceof Utf8) { + charSequence94 = (decoder).readString(((Utf8) oldString94)); + } else { + charSequence94 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(94, charSequence94); + } else { + throw new RuntimeException(("Illegal union index for 'F94': "+ unionIndex94)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema47(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex95 = (decoder.readIndex()); + if (unionIndex95 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(95, null); + } else { + if (unionIndex95 == 1) { + Utf8 charSequence95; + Object oldString95 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(95); + if (oldString95 instanceof Utf8) { + charSequence95 = (decoder).readString(((Utf8) oldString95)); + } else { + charSequence95 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(95, charSequence95); + } else { + throw new RuntimeException(("Illegal union index for 'F95': "+ unionIndex95)); + } + } + int unionIndex96 = (decoder.readIndex()); + if (unionIndex96 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(96, null); + } else { + if (unionIndex96 == 1) { + Utf8 charSequence96; + Object oldString96 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(96); + if (oldString96 instanceof Utf8) { + charSequence96 = (decoder).readString(((Utf8) oldString96)); + } else { + charSequence96 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(96, charSequence96); + } else { + throw new RuntimeException(("Illegal union index for 'F96': "+ unionIndex96)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema48(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex97 = (decoder.readIndex()); + if (unionIndex97 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(97, null); + } else { + if (unionIndex97 == 1) { + Utf8 charSequence97; + Object oldString97 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(97); + if (oldString97 instanceof Utf8) { + charSequence97 = (decoder).readString(((Utf8) oldString97)); + } else { + charSequence97 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(97, charSequence97); + } else { + throw new RuntimeException(("Illegal union index for 'F97': "+ unionIndex97)); + } + } + int unionIndex98 = (decoder.readIndex()); + if (unionIndex98 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(98, null); + } else { + if (unionIndex98 == 1) { + Utf8 charSequence98; + Object oldString98 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(98); + if (oldString98 instanceof Utf8) { + charSequence98 = (decoder).readString(((Utf8) oldString98)); + } else { + charSequence98 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(98, charSequence98); + } else { + throw new RuntimeException(("Illegal union index for 'F98': "+ unionIndex98)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema49(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex99 = (decoder.readIndex()); + if (unionIndex99 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(99, null); + } else { + if (unionIndex99 == 1) { + Utf8 charSequence99; + Object oldString99 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(99); + if (oldString99 instanceof Utf8) { + charSequence99 = (decoder).readString(((Utf8) oldString99)); + } else { + charSequence99 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(99, charSequence99); + } else { + throw new RuntimeException(("Illegal union index for 'F99': "+ unionIndex99)); + } + } + int unionIndex100 = (decoder.readIndex()); + if (unionIndex100 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(100, null); + } else { + if (unionIndex100 == 1) { + Utf8 charSequence100; + Object oldString100 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(100); + if (oldString100 instanceof Utf8) { + charSequence100 = (decoder).readString(((Utf8) oldString100)); + } else { + charSequence100 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(100, charSequence100); + } else { + throw new RuntimeException(("Illegal union index for 'F100': "+ unionIndex100)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema50(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex101 = (decoder.readIndex()); + if (unionIndex101 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(101, null); + } else { + if (unionIndex101 == 1) { + Utf8 charSequence101; + Object oldString101 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(101); + if (oldString101 instanceof Utf8) { + charSequence101 = (decoder).readString(((Utf8) oldString101)); + } else { + charSequence101 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(101, charSequence101); + } else { + throw new RuntimeException(("Illegal union index for 'F101': "+ unionIndex101)); + } + } + int unionIndex102 = (decoder.readIndex()); + if (unionIndex102 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(102, null); + } else { + if (unionIndex102 == 1) { + Utf8 charSequence102; + Object oldString102 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(102); + if (oldString102 instanceof Utf8) { + charSequence102 = (decoder).readString(((Utf8) oldString102)); + } else { + charSequence102 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(102, charSequence102); + } else { + throw new RuntimeException(("Illegal union index for 'F102': "+ unionIndex102)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema51(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex103 = (decoder.readIndex()); + if (unionIndex103 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(103, null); + } else { + if (unionIndex103 == 1) { + Utf8 charSequence103; + Object oldString103 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(103); + if (oldString103 instanceof Utf8) { + charSequence103 = (decoder).readString(((Utf8) oldString103)); + } else { + charSequence103 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(103, charSequence103); + } else { + throw new RuntimeException(("Illegal union index for 'F103': "+ unionIndex103)); + } + } + int unionIndex104 = (decoder.readIndex()); + if (unionIndex104 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(104, null); + } else { + if (unionIndex104 == 1) { + Utf8 charSequence104; + Object oldString104 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(104); + if (oldString104 instanceof Utf8) { + charSequence104 = (decoder).readString(((Utf8) oldString104)); + } else { + charSequence104 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(104, charSequence104); + } else { + throw new RuntimeException(("Illegal union index for 'F104': "+ unionIndex104)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema52(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex105 = (decoder.readIndex()); + if (unionIndex105 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(105, null); + } else { + if (unionIndex105 == 1) { + Utf8 charSequence105; + Object oldString105 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(105); + if (oldString105 instanceof Utf8) { + charSequence105 = (decoder).readString(((Utf8) oldString105)); + } else { + charSequence105 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(105, charSequence105); + } else { + throw new RuntimeException(("Illegal union index for 'F105': "+ unionIndex105)); + } + } + int unionIndex106 = (decoder.readIndex()); + if (unionIndex106 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(106, null); + } else { + if (unionIndex106 == 1) { + Utf8 charSequence106; + Object oldString106 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(106); + if (oldString106 instanceof Utf8) { + charSequence106 = (decoder).readString(((Utf8) oldString106)); + } else { + charSequence106 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(106, charSequence106); + } else { + throw new RuntimeException(("Illegal union index for 'F106': "+ unionIndex106)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema53(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex107 = (decoder.readIndex()); + if (unionIndex107 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(107, null); + } else { + if (unionIndex107 == 1) { + Utf8 charSequence107; + Object oldString107 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(107); + if (oldString107 instanceof Utf8) { + charSequence107 = (decoder).readString(((Utf8) oldString107)); + } else { + charSequence107 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(107, charSequence107); + } else { + throw new RuntimeException(("Illegal union index for 'F107': "+ unionIndex107)); + } + } + int unionIndex108 = (decoder.readIndex()); + if (unionIndex108 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(108, null); + } else { + if (unionIndex108 == 1) { + Utf8 charSequence108; + Object oldString108 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(108); + if (oldString108 instanceof Utf8) { + charSequence108 = (decoder).readString(((Utf8) oldString108)); + } else { + charSequence108 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(108, charSequence108); + } else { + throw new RuntimeException(("Illegal union index for 'F108': "+ unionIndex108)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema54(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex109 = (decoder.readIndex()); + if (unionIndex109 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(109, null); + } else { + if (unionIndex109 == 1) { + Utf8 charSequence109; + Object oldString109 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(109); + if (oldString109 instanceof Utf8) { + charSequence109 = (decoder).readString(((Utf8) oldString109)); + } else { + charSequence109 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(109, charSequence109); + } else { + throw new RuntimeException(("Illegal union index for 'F109': "+ unionIndex109)); + } + } + int unionIndex110 = (decoder.readIndex()); + if (unionIndex110 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(110, null); + } else { + if (unionIndex110 == 1) { + Utf8 charSequence110; + Object oldString110 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(110); + if (oldString110 instanceof Utf8) { + charSequence110 = (decoder).readString(((Utf8) oldString110)); + } else { + charSequence110 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(110, charSequence110); + } else { + throw new RuntimeException(("Illegal union index for 'F110': "+ unionIndex110)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema55(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex111 = (decoder.readIndex()); + if (unionIndex111 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(111, null); + } else { + if (unionIndex111 == 1) { + Utf8 charSequence111; + Object oldString111 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(111); + if (oldString111 instanceof Utf8) { + charSequence111 = (decoder).readString(((Utf8) oldString111)); + } else { + charSequence111 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(111, charSequence111); + } else { + throw new RuntimeException(("Illegal union index for 'F111': "+ unionIndex111)); + } + } + int unionIndex112 = (decoder.readIndex()); + if (unionIndex112 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(112, null); + } else { + if (unionIndex112 == 1) { + Utf8 charSequence112; + Object oldString112 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(112); + if (oldString112 instanceof Utf8) { + charSequence112 = (decoder).readString(((Utf8) oldString112)); + } else { + charSequence112 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(112, charSequence112); + } else { + throw new RuntimeException(("Illegal union index for 'F112': "+ unionIndex112)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema56(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex113 = (decoder.readIndex()); + if (unionIndex113 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(113, null); + } else { + if (unionIndex113 == 1) { + Utf8 charSequence113; + Object oldString113 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(113); + if (oldString113 instanceof Utf8) { + charSequence113 = (decoder).readString(((Utf8) oldString113)); + } else { + charSequence113 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(113, charSequence113); + } else { + throw new RuntimeException(("Illegal union index for 'F113': "+ unionIndex113)); + } + } + int unionIndex114 = (decoder.readIndex()); + if (unionIndex114 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(114, null); + } else { + if (unionIndex114 == 1) { + Utf8 charSequence114; + Object oldString114 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(114); + if (oldString114 instanceof Utf8) { + charSequence114 = (decoder).readString(((Utf8) oldString114)); + } else { + charSequence114 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(114, charSequence114); + } else { + throw new RuntimeException(("Illegal union index for 'F114': "+ unionIndex114)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema57(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex115 = (decoder.readIndex()); + if (unionIndex115 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(115, null); + } else { + if (unionIndex115 == 1) { + Utf8 charSequence115; + Object oldString115 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(115); + if (oldString115 instanceof Utf8) { + charSequence115 = (decoder).readString(((Utf8) oldString115)); + } else { + charSequence115 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(115, charSequence115); + } else { + throw new RuntimeException(("Illegal union index for 'F115': "+ unionIndex115)); + } + } + int unionIndex116 = (decoder.readIndex()); + if (unionIndex116 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(116, null); + } else { + if (unionIndex116 == 1) { + Utf8 charSequence116; + Object oldString116 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(116); + if (oldString116 instanceof Utf8) { + charSequence116 = (decoder).readString(((Utf8) oldString116)); + } else { + charSequence116 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(116, charSequence116); + } else { + throw new RuntimeException(("Illegal union index for 'F116': "+ unionIndex116)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema58(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex117 = (decoder.readIndex()); + if (unionIndex117 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(117, null); + } else { + if (unionIndex117 == 1) { + Utf8 charSequence117; + Object oldString117 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(117); + if (oldString117 instanceof Utf8) { + charSequence117 = (decoder).readString(((Utf8) oldString117)); + } else { + charSequence117 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(117, charSequence117); + } else { + throw new RuntimeException(("Illegal union index for 'F117': "+ unionIndex117)); + } + } + int unionIndex118 = (decoder.readIndex()); + if (unionIndex118 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(118, null); + } else { + if (unionIndex118 == 1) { + Utf8 charSequence118; + Object oldString118 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(118); + if (oldString118 instanceof Utf8) { + charSequence118 = (decoder).readString(((Utf8) oldString118)); + } else { + charSequence118 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(118, charSequence118); + } else { + throw new RuntimeException(("Illegal union index for 'F118': "+ unionIndex118)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema59(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex119 = (decoder.readIndex()); + if (unionIndex119 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(119, null); + } else { + if (unionIndex119 == 1) { + Utf8 charSequence119; + Object oldString119 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(119); + if (oldString119 instanceof Utf8) { + charSequence119 = (decoder).readString(((Utf8) oldString119)); + } else { + charSequence119 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(119, charSequence119); + } else { + throw new RuntimeException(("Illegal union index for 'F119': "+ unionIndex119)); + } + } + int unionIndex120 = (decoder.readIndex()); + if (unionIndex120 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(120, null); + } else { + if (unionIndex120 == 1) { + Utf8 charSequence120; + Object oldString120 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(120); + if (oldString120 instanceof Utf8) { + charSequence120 = (decoder).readString(((Utf8) oldString120)); + } else { + charSequence120 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(120, charSequence120); + } else { + throw new RuntimeException(("Illegal union index for 'F120': "+ unionIndex120)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema60(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex121 = (decoder.readIndex()); + if (unionIndex121 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(121, null); + } else { + if (unionIndex121 == 1) { + Utf8 charSequence121; + Object oldString121 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(121); + if (oldString121 instanceof Utf8) { + charSequence121 = (decoder).readString(((Utf8) oldString121)); + } else { + charSequence121 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(121, charSequence121); + } else { + throw new RuntimeException(("Illegal union index for 'F121': "+ unionIndex121)); + } + } + int unionIndex122 = (decoder.readIndex()); + if (unionIndex122 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(122, null); + } else { + if (unionIndex122 == 1) { + Utf8 charSequence122; + Object oldString122 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(122); + if (oldString122 instanceof Utf8) { + charSequence122 = (decoder).readString(((Utf8) oldString122)); + } else { + charSequence122 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(122, charSequence122); + } else { + throw new RuntimeException(("Illegal union index for 'F122': "+ unionIndex122)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema61(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex123 = (decoder.readIndex()); + if (unionIndex123 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(123, null); + } else { + if (unionIndex123 == 1) { + Utf8 charSequence123; + Object oldString123 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(123); + if (oldString123 instanceof Utf8) { + charSequence123 = (decoder).readString(((Utf8) oldString123)); + } else { + charSequence123 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(123, charSequence123); + } else { + throw new RuntimeException(("Illegal union index for 'F123': "+ unionIndex123)); + } + } + int unionIndex124 = (decoder.readIndex()); + if (unionIndex124 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(124, null); + } else { + if (unionIndex124 == 1) { + Utf8 charSequence124; + Object oldString124 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(124); + if (oldString124 instanceof Utf8) { + charSequence124 = (decoder).readString(((Utf8) oldString124)); + } else { + charSequence124 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(124, charSequence124); + } else { + throw new RuntimeException(("Illegal union index for 'F124': "+ unionIndex124)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema62(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex125 = (decoder.readIndex()); + if (unionIndex125 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(125, null); + } else { + if (unionIndex125 == 1) { + Utf8 charSequence125; + Object oldString125 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(125); + if (oldString125 instanceof Utf8) { + charSequence125 = (decoder).readString(((Utf8) oldString125)); + } else { + charSequence125 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(125, charSequence125); + } else { + throw new RuntimeException(("Illegal union index for 'F125': "+ unionIndex125)); + } + } + int unionIndex126 = (decoder.readIndex()); + if (unionIndex126 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(126, null); + } else { + if (unionIndex126 == 1) { + Utf8 charSequence126; + Object oldString126 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(126); + if (oldString126 instanceof Utf8) { + charSequence126 = (decoder).readString(((Utf8) oldString126)); + } else { + charSequence126 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(126, charSequence126); + } else { + throw new RuntimeException(("Illegal union index for 'F126': "+ unionIndex126)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema63(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex127 = (decoder.readIndex()); + if (unionIndex127 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(127, null); + } else { + if (unionIndex127 == 1) { + Utf8 charSequence127; + Object oldString127 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(127); + if (oldString127 instanceof Utf8) { + charSequence127 = (decoder).readString(((Utf8) oldString127)); + } else { + charSequence127 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(127, charSequence127); + } else { + throw new RuntimeException(("Illegal union index for 'F127': "+ unionIndex127)); + } + } + int unionIndex128 = (decoder.readIndex()); + if (unionIndex128 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(128, null); + } else { + if (unionIndex128 == 1) { + Utf8 charSequence128; + Object oldString128 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(128); + if (oldString128 instanceof Utf8) { + charSequence128 = (decoder).readString(((Utf8) oldString128)); + } else { + charSequence128 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(128, charSequence128); + } else { + throw new RuntimeException(("Illegal union index for 'F128': "+ unionIndex128)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema64(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex129 = (decoder.readIndex()); + if (unionIndex129 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(129, null); + } else { + if (unionIndex129 == 1) { + Utf8 charSequence129; + Object oldString129 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(129); + if (oldString129 instanceof Utf8) { + charSequence129 = (decoder).readString(((Utf8) oldString129)); + } else { + charSequence129 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(129, charSequence129); + } else { + throw new RuntimeException(("Illegal union index for 'F129': "+ unionIndex129)); + } + } + int unionIndex130 = (decoder.readIndex()); + if (unionIndex130 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(130, null); + } else { + if (unionIndex130 == 1) { + Utf8 charSequence130; + Object oldString130 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(130); + if (oldString130 instanceof Utf8) { + charSequence130 = (decoder).readString(((Utf8) oldString130)); + } else { + charSequence130 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(130, charSequence130); + } else { + throw new RuntimeException(("Illegal union index for 'F130': "+ unionIndex130)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema65(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex131 = (decoder.readIndex()); + if (unionIndex131 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(131, null); + } else { + if (unionIndex131 == 1) { + Utf8 charSequence131; + Object oldString131 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(131); + if (oldString131 instanceof Utf8) { + charSequence131 = (decoder).readString(((Utf8) oldString131)); + } else { + charSequence131 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(131, charSequence131); + } else { + throw new RuntimeException(("Illegal union index for 'F131': "+ unionIndex131)); + } + } + int unionIndex132 = (decoder.readIndex()); + if (unionIndex132 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(132, null); + } else { + if (unionIndex132 == 1) { + Utf8 charSequence132; + Object oldString132 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(132); + if (oldString132 instanceof Utf8) { + charSequence132 = (decoder).readString(((Utf8) oldString132)); + } else { + charSequence132 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(132, charSequence132); + } else { + throw new RuntimeException(("Illegal union index for 'F132': "+ unionIndex132)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema66(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex133 = (decoder.readIndex()); + if (unionIndex133 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(133, null); + } else { + if (unionIndex133 == 1) { + Utf8 charSequence133; + Object oldString133 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(133); + if (oldString133 instanceof Utf8) { + charSequence133 = (decoder).readString(((Utf8) oldString133)); + } else { + charSequence133 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(133, charSequence133); + } else { + throw new RuntimeException(("Illegal union index for 'F133': "+ unionIndex133)); + } + } + int unionIndex134 = (decoder.readIndex()); + if (unionIndex134 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(134, null); + } else { + if (unionIndex134 == 1) { + Utf8 charSequence134; + Object oldString134 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(134); + if (oldString134 instanceof Utf8) { + charSequence134 = (decoder).readString(((Utf8) oldString134)); + } else { + charSequence134 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(134, charSequence134); + } else { + throw new RuntimeException(("Illegal union index for 'F134': "+ unionIndex134)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema67(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex135 = (decoder.readIndex()); + if (unionIndex135 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(135, null); + } else { + if (unionIndex135 == 1) { + Utf8 charSequence135; + Object oldString135 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(135); + if (oldString135 instanceof Utf8) { + charSequence135 = (decoder).readString(((Utf8) oldString135)); + } else { + charSequence135 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(135, charSequence135); + } else { + throw new RuntimeException(("Illegal union index for 'F135': "+ unionIndex135)); + } + } + int unionIndex136 = (decoder.readIndex()); + if (unionIndex136 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(136, null); + } else { + if (unionIndex136 == 1) { + Utf8 charSequence136; + Object oldString136 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(136); + if (oldString136 instanceof Utf8) { + charSequence136 = (decoder).readString(((Utf8) oldString136)); + } else { + charSequence136 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(136, charSequence136); + } else { + throw new RuntimeException(("Illegal union index for 'F136': "+ unionIndex136)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema68(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex137 = (decoder.readIndex()); + if (unionIndex137 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(137, null); + } else { + if (unionIndex137 == 1) { + Utf8 charSequence137; + Object oldString137 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(137); + if (oldString137 instanceof Utf8) { + charSequence137 = (decoder).readString(((Utf8) oldString137)); + } else { + charSequence137 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(137, charSequence137); + } else { + throw new RuntimeException(("Illegal union index for 'F137': "+ unionIndex137)); + } + } + int unionIndex138 = (decoder.readIndex()); + if (unionIndex138 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(138, null); + } else { + if (unionIndex138 == 1) { + Utf8 charSequence138; + Object oldString138 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(138); + if (oldString138 instanceof Utf8) { + charSequence138 = (decoder).readString(((Utf8) oldString138)); + } else { + charSequence138 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(138, charSequence138); + } else { + throw new RuntimeException(("Illegal union index for 'F138': "+ unionIndex138)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema69(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex139 = (decoder.readIndex()); + if (unionIndex139 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(139, null); + } else { + if (unionIndex139 == 1) { + Utf8 charSequence139; + Object oldString139 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(139); + if (oldString139 instanceof Utf8) { + charSequence139 = (decoder).readString(((Utf8) oldString139)); + } else { + charSequence139 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(139, charSequence139); + } else { + throw new RuntimeException(("Illegal union index for 'F139': "+ unionIndex139)); + } + } + int unionIndex140 = (decoder.readIndex()); + if (unionIndex140 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(140, null); + } else { + if (unionIndex140 == 1) { + Utf8 charSequence140; + Object oldString140 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(140); + if (oldString140 instanceof Utf8) { + charSequence140 = (decoder).readString(((Utf8) oldString140)); + } else { + charSequence140 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(140, charSequence140); + } else { + throw new RuntimeException(("Illegal union index for 'F140': "+ unionIndex140)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema70(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex141 = (decoder.readIndex()); + if (unionIndex141 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(141, null); + } else { + if (unionIndex141 == 1) { + Utf8 charSequence141; + Object oldString141 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(141); + if (oldString141 instanceof Utf8) { + charSequence141 = (decoder).readString(((Utf8) oldString141)); + } else { + charSequence141 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(141, charSequence141); + } else { + throw new RuntimeException(("Illegal union index for 'F141': "+ unionIndex141)); + } + } + int unionIndex142 = (decoder.readIndex()); + if (unionIndex142 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(142, null); + } else { + if (unionIndex142 == 1) { + Utf8 charSequence142; + Object oldString142 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(142); + if (oldString142 instanceof Utf8) { + charSequence142 = (decoder).readString(((Utf8) oldString142)); + } else { + charSequence142 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(142, charSequence142); + } else { + throw new RuntimeException(("Illegal union index for 'F142': "+ unionIndex142)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema71(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex143 = (decoder.readIndex()); + if (unionIndex143 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(143, null); + } else { + if (unionIndex143 == 1) { + Utf8 charSequence143; + Object oldString143 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(143); + if (oldString143 instanceof Utf8) { + charSequence143 = (decoder).readString(((Utf8) oldString143)); + } else { + charSequence143 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(143, charSequence143); + } else { + throw new RuntimeException(("Illegal union index for 'F143': "+ unionIndex143)); + } + } + int unionIndex144 = (decoder.readIndex()); + if (unionIndex144 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(144, null); + } else { + if (unionIndex144 == 1) { + Utf8 charSequence144; + Object oldString144 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(144); + if (oldString144 instanceof Utf8) { + charSequence144 = (decoder).readString(((Utf8) oldString144)); + } else { + charSequence144 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(144, charSequence144); + } else { + throw new RuntimeException(("Illegal union index for 'F144': "+ unionIndex144)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema72(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex145 = (decoder.readIndex()); + if (unionIndex145 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(145, null); + } else { + if (unionIndex145 == 1) { + Utf8 charSequence145; + Object oldString145 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(145); + if (oldString145 instanceof Utf8) { + charSequence145 = (decoder).readString(((Utf8) oldString145)); + } else { + charSequence145 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(145, charSequence145); + } else { + throw new RuntimeException(("Illegal union index for 'F145': "+ unionIndex145)); + } + } + int unionIndex146 = (decoder.readIndex()); + if (unionIndex146 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(146, null); + } else { + if (unionIndex146 == 1) { + Utf8 charSequence146; + Object oldString146 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(146); + if (oldString146 instanceof Utf8) { + charSequence146 = (decoder).readString(((Utf8) oldString146)); + } else { + charSequence146 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(146, charSequence146); + } else { + throw new RuntimeException(("Illegal union index for 'F146': "+ unionIndex146)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema73(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex147 = (decoder.readIndex()); + if (unionIndex147 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(147, null); + } else { + if (unionIndex147 == 1) { + Utf8 charSequence147; + Object oldString147 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(147); + if (oldString147 instanceof Utf8) { + charSequence147 = (decoder).readString(((Utf8) oldString147)); + } else { + charSequence147 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(147, charSequence147); + } else { + throw new RuntimeException(("Illegal union index for 'F147': "+ unionIndex147)); + } + } + int unionIndex148 = (decoder.readIndex()); + if (unionIndex148 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(148, null); + } else { + if (unionIndex148 == 1) { + Utf8 charSequence148; + Object oldString148 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(148); + if (oldString148 instanceof Utf8) { + charSequence148 = (decoder).readString(((Utf8) oldString148)); + } else { + charSequence148 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(148, charSequence148); + } else { + throw new RuntimeException(("Illegal union index for 'F148': "+ unionIndex148)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema74(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex149 = (decoder.readIndex()); + if (unionIndex149 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(149, null); + } else { + if (unionIndex149 == 1) { + Utf8 charSequence149; + Object oldString149 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(149); + if (oldString149 instanceof Utf8) { + charSequence149 = (decoder).readString(((Utf8) oldString149)); + } else { + charSequence149 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(149, charSequence149); + } else { + throw new RuntimeException(("Illegal union index for 'F149': "+ unionIndex149)); + } + } + int unionIndex150 = (decoder.readIndex()); + if (unionIndex150 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(150, null); + } else { + if (unionIndex150 == 1) { + Utf8 charSequence150; + Object oldString150 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(150); + if (oldString150 instanceof Utf8) { + charSequence150 = (decoder).readString(((Utf8) oldString150)); + } else { + charSequence150 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(150, charSequence150); + } else { + throw new RuntimeException(("Illegal union index for 'F150': "+ unionIndex150)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema75(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex151 = (decoder.readIndex()); + if (unionIndex151 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(151, null); + } else { + if (unionIndex151 == 1) { + Utf8 charSequence151; + Object oldString151 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(151); + if (oldString151 instanceof Utf8) { + charSequence151 = (decoder).readString(((Utf8) oldString151)); + } else { + charSequence151 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(151, charSequence151); + } else { + throw new RuntimeException(("Illegal union index for 'F151': "+ unionIndex151)); + } + } + int unionIndex152 = (decoder.readIndex()); + if (unionIndex152 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(152, null); + } else { + if (unionIndex152 == 1) { + Utf8 charSequence152; + Object oldString152 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(152); + if (oldString152 instanceof Utf8) { + charSequence152 = (decoder).readString(((Utf8) oldString152)); + } else { + charSequence152 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(152, charSequence152); + } else { + throw new RuntimeException(("Illegal union index for 'F152': "+ unionIndex152)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema76(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex153 = (decoder.readIndex()); + if (unionIndex153 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(153, null); + } else { + if (unionIndex153 == 1) { + Utf8 charSequence153; + Object oldString153 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(153); + if (oldString153 instanceof Utf8) { + charSequence153 = (decoder).readString(((Utf8) oldString153)); + } else { + charSequence153 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(153, charSequence153); + } else { + throw new RuntimeException(("Illegal union index for 'F153': "+ unionIndex153)); + } + } + int unionIndex154 = (decoder.readIndex()); + if (unionIndex154 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(154, null); + } else { + if (unionIndex154 == 1) { + Utf8 charSequence154; + Object oldString154 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(154); + if (oldString154 instanceof Utf8) { + charSequence154 = (decoder).readString(((Utf8) oldString154)); + } else { + charSequence154 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(154, charSequence154); + } else { + throw new RuntimeException(("Illegal union index for 'F154': "+ unionIndex154)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema77(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex155 = (decoder.readIndex()); + if (unionIndex155 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(155, null); + } else { + if (unionIndex155 == 1) { + Utf8 charSequence155; + Object oldString155 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(155); + if (oldString155 instanceof Utf8) { + charSequence155 = (decoder).readString(((Utf8) oldString155)); + } else { + charSequence155 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(155, charSequence155); + } else { + throw new RuntimeException(("Illegal union index for 'F155': "+ unionIndex155)); + } + } + int unionIndex156 = (decoder.readIndex()); + if (unionIndex156 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(156, null); + } else { + if (unionIndex156 == 1) { + Utf8 charSequence156; + Object oldString156 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(156); + if (oldString156 instanceof Utf8) { + charSequence156 = (decoder).readString(((Utf8) oldString156)); + } else { + charSequence156 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(156, charSequence156); + } else { + throw new RuntimeException(("Illegal union index for 'F156': "+ unionIndex156)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema78(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex157 = (decoder.readIndex()); + if (unionIndex157 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(157, null); + } else { + if (unionIndex157 == 1) { + Utf8 charSequence157; + Object oldString157 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(157); + if (oldString157 instanceof Utf8) { + charSequence157 = (decoder).readString(((Utf8) oldString157)); + } else { + charSequence157 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(157, charSequence157); + } else { + throw new RuntimeException(("Illegal union index for 'F157': "+ unionIndex157)); + } + } + int unionIndex158 = (decoder.readIndex()); + if (unionIndex158 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(158, null); + } else { + if (unionIndex158 == 1) { + Utf8 charSequence158; + Object oldString158 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(158); + if (oldString158 instanceof Utf8) { + charSequence158 = (decoder).readString(((Utf8) oldString158)); + } else { + charSequence158 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(158, charSequence158); + } else { + throw new RuntimeException(("Illegal union index for 'F158': "+ unionIndex158)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema79(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex159 = (decoder.readIndex()); + if (unionIndex159 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(159, null); + } else { + if (unionIndex159 == 1) { + Utf8 charSequence159; + Object oldString159 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(159); + if (oldString159 instanceof Utf8) { + charSequence159 = (decoder).readString(((Utf8) oldString159)); + } else { + charSequence159 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(159, charSequence159); + } else { + throw new RuntimeException(("Illegal union index for 'F159': "+ unionIndex159)); + } + } + int unionIndex160 = (decoder.readIndex()); + if (unionIndex160 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(160, null); + } else { + if (unionIndex160 == 1) { + Utf8 charSequence160; + Object oldString160 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(160); + if (oldString160 instanceof Utf8) { + charSequence160 = (decoder).readString(((Utf8) oldString160)); + } else { + charSequence160 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(160, charSequence160); + } else { + throw new RuntimeException(("Illegal union index for 'F160': "+ unionIndex160)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema80(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex161 = (decoder.readIndex()); + if (unionIndex161 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(161, null); + } else { + if (unionIndex161 == 1) { + Utf8 charSequence161; + Object oldString161 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(161); + if (oldString161 instanceof Utf8) { + charSequence161 = (decoder).readString(((Utf8) oldString161)); + } else { + charSequence161 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(161, charSequence161); + } else { + throw new RuntimeException(("Illegal union index for 'F161': "+ unionIndex161)); + } + } + int unionIndex162 = (decoder.readIndex()); + if (unionIndex162 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(162, null); + } else { + if (unionIndex162 == 1) { + Utf8 charSequence162; + Object oldString162 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(162); + if (oldString162 instanceof Utf8) { + charSequence162 = (decoder).readString(((Utf8) oldString162)); + } else { + charSequence162 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(162, charSequence162); + } else { + throw new RuntimeException(("Illegal union index for 'F162': "+ unionIndex162)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema81(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex163 = (decoder.readIndex()); + if (unionIndex163 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(163, null); + } else { + if (unionIndex163 == 1) { + Utf8 charSequence163; + Object oldString163 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(163); + if (oldString163 instanceof Utf8) { + charSequence163 = (decoder).readString(((Utf8) oldString163)); + } else { + charSequence163 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(163, charSequence163); + } else { + throw new RuntimeException(("Illegal union index for 'F163': "+ unionIndex163)); + } + } + int unionIndex164 = (decoder.readIndex()); + if (unionIndex164 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(164, null); + } else { + if (unionIndex164 == 1) { + Utf8 charSequence164; + Object oldString164 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(164); + if (oldString164 instanceof Utf8) { + charSequence164 = (decoder).readString(((Utf8) oldString164)); + } else { + charSequence164 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(164, charSequence164); + } else { + throw new RuntimeException(("Illegal union index for 'F164': "+ unionIndex164)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema82(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex165 = (decoder.readIndex()); + if (unionIndex165 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(165, null); + } else { + if (unionIndex165 == 1) { + Utf8 charSequence165; + Object oldString165 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(165); + if (oldString165 instanceof Utf8) { + charSequence165 = (decoder).readString(((Utf8) oldString165)); + } else { + charSequence165 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(165, charSequence165); + } else { + throw new RuntimeException(("Illegal union index for 'F165': "+ unionIndex165)); + } + } + int unionIndex166 = (decoder.readIndex()); + if (unionIndex166 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(166, null); + } else { + if (unionIndex166 == 1) { + Utf8 charSequence166; + Object oldString166 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(166); + if (oldString166 instanceof Utf8) { + charSequence166 = (decoder).readString(((Utf8) oldString166)); + } else { + charSequence166 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(166, charSequence166); + } else { + throw new RuntimeException(("Illegal union index for 'F166': "+ unionIndex166)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema83(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex167 = (decoder.readIndex()); + if (unionIndex167 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(167, null); + } else { + if (unionIndex167 == 1) { + Utf8 charSequence167; + Object oldString167 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(167); + if (oldString167 instanceof Utf8) { + charSequence167 = (decoder).readString(((Utf8) oldString167)); + } else { + charSequence167 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(167, charSequence167); + } else { + throw new RuntimeException(("Illegal union index for 'F167': "+ unionIndex167)); + } + } + int unionIndex168 = (decoder.readIndex()); + if (unionIndex168 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(168, null); + } else { + if (unionIndex168 == 1) { + Utf8 charSequence168; + Object oldString168 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(168); + if (oldString168 instanceof Utf8) { + charSequence168 = (decoder).readString(((Utf8) oldString168)); + } else { + charSequence168 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(168, charSequence168); + } else { + throw new RuntimeException(("Illegal union index for 'F168': "+ unionIndex168)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema84(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex169 = (decoder.readIndex()); + if (unionIndex169 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(169, null); + } else { + if (unionIndex169 == 1) { + Utf8 charSequence169; + Object oldString169 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(169); + if (oldString169 instanceof Utf8) { + charSequence169 = (decoder).readString(((Utf8) oldString169)); + } else { + charSequence169 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(169, charSequence169); + } else { + throw new RuntimeException(("Illegal union index for 'F169': "+ unionIndex169)); + } + } + int unionIndex170 = (decoder.readIndex()); + if (unionIndex170 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(170, null); + } else { + if (unionIndex170 == 1) { + Utf8 charSequence170; + Object oldString170 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(170); + if (oldString170 instanceof Utf8) { + charSequence170 = (decoder).readString(((Utf8) oldString170)); + } else { + charSequence170 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(170, charSequence170); + } else { + throw new RuntimeException(("Illegal union index for 'F170': "+ unionIndex170)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema85(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex171 = (decoder.readIndex()); + if (unionIndex171 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(171, null); + } else { + if (unionIndex171 == 1) { + Utf8 charSequence171; + Object oldString171 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(171); + if (oldString171 instanceof Utf8) { + charSequence171 = (decoder).readString(((Utf8) oldString171)); + } else { + charSequence171 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(171, charSequence171); + } else { + throw new RuntimeException(("Illegal union index for 'F171': "+ unionIndex171)); + } + } + int unionIndex172 = (decoder.readIndex()); + if (unionIndex172 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(172, null); + } else { + if (unionIndex172 == 1) { + Utf8 charSequence172; + Object oldString172 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(172); + if (oldString172 instanceof Utf8) { + charSequence172 = (decoder).readString(((Utf8) oldString172)); + } else { + charSequence172 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(172, charSequence172); + } else { + throw new RuntimeException(("Illegal union index for 'F172': "+ unionIndex172)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema86(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex173 = (decoder.readIndex()); + if (unionIndex173 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(173, null); + } else { + if (unionIndex173 == 1) { + Utf8 charSequence173; + Object oldString173 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(173); + if (oldString173 instanceof Utf8) { + charSequence173 = (decoder).readString(((Utf8) oldString173)); + } else { + charSequence173 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(173, charSequence173); + } else { + throw new RuntimeException(("Illegal union index for 'F173': "+ unionIndex173)); + } + } + int unionIndex174 = (decoder.readIndex()); + if (unionIndex174 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(174, null); + } else { + if (unionIndex174 == 1) { + Utf8 charSequence174; + Object oldString174 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(174); + if (oldString174 instanceof Utf8) { + charSequence174 = (decoder).readString(((Utf8) oldString174)); + } else { + charSequence174 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(174, charSequence174); + } else { + throw new RuntimeException(("Illegal union index for 'F174': "+ unionIndex174)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema87(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex175 = (decoder.readIndex()); + if (unionIndex175 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(175, null); + } else { + if (unionIndex175 == 1) { + Utf8 charSequence175; + Object oldString175 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(175); + if (oldString175 instanceof Utf8) { + charSequence175 = (decoder).readString(((Utf8) oldString175)); + } else { + charSequence175 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(175, charSequence175); + } else { + throw new RuntimeException(("Illegal union index for 'F175': "+ unionIndex175)); + } + } + int unionIndex176 = (decoder.readIndex()); + if (unionIndex176 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(176, null); + } else { + if (unionIndex176 == 1) { + Utf8 charSequence176; + Object oldString176 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(176); + if (oldString176 instanceof Utf8) { + charSequence176 = (decoder).readString(((Utf8) oldString176)); + } else { + charSequence176 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(176, charSequence176); + } else { + throw new RuntimeException(("Illegal union index for 'F176': "+ unionIndex176)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema88(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex177 = (decoder.readIndex()); + if (unionIndex177 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(177, null); + } else { + if (unionIndex177 == 1) { + Utf8 charSequence177; + Object oldString177 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(177); + if (oldString177 instanceof Utf8) { + charSequence177 = (decoder).readString(((Utf8) oldString177)); + } else { + charSequence177 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(177, charSequence177); + } else { + throw new RuntimeException(("Illegal union index for 'F177': "+ unionIndex177)); + } + } + int unionIndex178 = (decoder.readIndex()); + if (unionIndex178 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(178, null); + } else { + if (unionIndex178 == 1) { + Utf8 charSequence178; + Object oldString178 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(178); + if (oldString178 instanceof Utf8) { + charSequence178 = (decoder).readString(((Utf8) oldString178)); + } else { + charSequence178 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(178, charSequence178); + } else { + throw new RuntimeException(("Illegal union index for 'F178': "+ unionIndex178)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema89(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex179 = (decoder.readIndex()); + if (unionIndex179 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(179, null); + } else { + if (unionIndex179 == 1) { + Utf8 charSequence179; + Object oldString179 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(179); + if (oldString179 instanceof Utf8) { + charSequence179 = (decoder).readString(((Utf8) oldString179)); + } else { + charSequence179 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(179, charSequence179); + } else { + throw new RuntimeException(("Illegal union index for 'F179': "+ unionIndex179)); + } + } + int unionIndex180 = (decoder.readIndex()); + if (unionIndex180 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(180, null); + } else { + if (unionIndex180 == 1) { + Utf8 charSequence180; + Object oldString180 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(180); + if (oldString180 instanceof Utf8) { + charSequence180 = (decoder).readString(((Utf8) oldString180)); + } else { + charSequence180 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(180, charSequence180); + } else { + throw new RuntimeException(("Illegal union index for 'F180': "+ unionIndex180)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema90(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex181 = (decoder.readIndex()); + if (unionIndex181 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(181, null); + } else { + if (unionIndex181 == 1) { + Utf8 charSequence181; + Object oldString181 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(181); + if (oldString181 instanceof Utf8) { + charSequence181 = (decoder).readString(((Utf8) oldString181)); + } else { + charSequence181 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(181, charSequence181); + } else { + throw new RuntimeException(("Illegal union index for 'F181': "+ unionIndex181)); + } + } + int unionIndex182 = (decoder.readIndex()); + if (unionIndex182 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(182, null); + } else { + if (unionIndex182 == 1) { + Utf8 charSequence182; + Object oldString182 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(182); + if (oldString182 instanceof Utf8) { + charSequence182 = (decoder).readString(((Utf8) oldString182)); + } else { + charSequence182 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(182, charSequence182); + } else { + throw new RuntimeException(("Illegal union index for 'F182': "+ unionIndex182)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema91(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex183 = (decoder.readIndex()); + if (unionIndex183 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(183, null); + } else { + if (unionIndex183 == 1) { + Utf8 charSequence183; + Object oldString183 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(183); + if (oldString183 instanceof Utf8) { + charSequence183 = (decoder).readString(((Utf8) oldString183)); + } else { + charSequence183 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(183, charSequence183); + } else { + throw new RuntimeException(("Illegal union index for 'F183': "+ unionIndex183)); + } + } + int unionIndex184 = (decoder.readIndex()); + if (unionIndex184 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(184, null); + } else { + if (unionIndex184 == 1) { + Utf8 charSequence184; + Object oldString184 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(184); + if (oldString184 instanceof Utf8) { + charSequence184 = (decoder).readString(((Utf8) oldString184)); + } else { + charSequence184 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(184, charSequence184); + } else { + throw new RuntimeException(("Illegal union index for 'F184': "+ unionIndex184)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema92(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex185 = (decoder.readIndex()); + if (unionIndex185 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(185, null); + } else { + if (unionIndex185 == 1) { + Utf8 charSequence185; + Object oldString185 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(185); + if (oldString185 instanceof Utf8) { + charSequence185 = (decoder).readString(((Utf8) oldString185)); + } else { + charSequence185 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(185, charSequence185); + } else { + throw new RuntimeException(("Illegal union index for 'F185': "+ unionIndex185)); + } + } + int unionIndex186 = (decoder.readIndex()); + if (unionIndex186 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(186, null); + } else { + if (unionIndex186 == 1) { + Utf8 charSequence186; + Object oldString186 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(186); + if (oldString186 instanceof Utf8) { + charSequence186 = (decoder).readString(((Utf8) oldString186)); + } else { + charSequence186 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(186, charSequence186); + } else { + throw new RuntimeException(("Illegal union index for 'F186': "+ unionIndex186)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema93(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex187 = (decoder.readIndex()); + if (unionIndex187 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(187, null); + } else { + if (unionIndex187 == 1) { + Utf8 charSequence187; + Object oldString187 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(187); + if (oldString187 instanceof Utf8) { + charSequence187 = (decoder).readString(((Utf8) oldString187)); + } else { + charSequence187 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(187, charSequence187); + } else { + throw new RuntimeException(("Illegal union index for 'F187': "+ unionIndex187)); + } + } + int unionIndex188 = (decoder.readIndex()); + if (unionIndex188 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(188, null); + } else { + if (unionIndex188 == 1) { + Utf8 charSequence188; + Object oldString188 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(188); + if (oldString188 instanceof Utf8) { + charSequence188 = (decoder).readString(((Utf8) oldString188)); + } else { + charSequence188 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(188, charSequence188); + } else { + throw new RuntimeException(("Illegal union index for 'F188': "+ unionIndex188)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema94(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex189 = (decoder.readIndex()); + if (unionIndex189 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(189, null); + } else { + if (unionIndex189 == 1) { + Utf8 charSequence189; + Object oldString189 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(189); + if (oldString189 instanceof Utf8) { + charSequence189 = (decoder).readString(((Utf8) oldString189)); + } else { + charSequence189 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(189, charSequence189); + } else { + throw new RuntimeException(("Illegal union index for 'F189': "+ unionIndex189)); + } + } + int unionIndex190 = (decoder.readIndex()); + if (unionIndex190 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(190, null); + } else { + if (unionIndex190 == 1) { + Utf8 charSequence190; + Object oldString190 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(190); + if (oldString190 instanceof Utf8) { + charSequence190 = (decoder).readString(((Utf8) oldString190)); + } else { + charSequence190 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(190, charSequence190); + } else { + throw new RuntimeException(("Illegal union index for 'F190': "+ unionIndex190)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema95(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex191 = (decoder.readIndex()); + if (unionIndex191 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(191, null); + } else { + if (unionIndex191 == 1) { + Utf8 charSequence191; + Object oldString191 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(191); + if (oldString191 instanceof Utf8) { + charSequence191 = (decoder).readString(((Utf8) oldString191)); + } else { + charSequence191 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(191, charSequence191); + } else { + throw new RuntimeException(("Illegal union index for 'F191': "+ unionIndex191)); + } + } + int unionIndex192 = (decoder.readIndex()); + if (unionIndex192 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(192, null); + } else { + if (unionIndex192 == 1) { + Utf8 charSequence192; + Object oldString192 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(192); + if (oldString192 instanceof Utf8) { + charSequence192 = (decoder).readString(((Utf8) oldString192)); + } else { + charSequence192 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(192, charSequence192); + } else { + throw new RuntimeException(("Illegal union index for 'F192': "+ unionIndex192)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema96(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex193 = (decoder.readIndex()); + if (unionIndex193 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(193, null); + } else { + if (unionIndex193 == 1) { + Utf8 charSequence193; + Object oldString193 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(193); + if (oldString193 instanceof Utf8) { + charSequence193 = (decoder).readString(((Utf8) oldString193)); + } else { + charSequence193 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(193, charSequence193); + } else { + throw new RuntimeException(("Illegal union index for 'F193': "+ unionIndex193)); + } + } + int unionIndex194 = (decoder.readIndex()); + if (unionIndex194 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(194, null); + } else { + if (unionIndex194 == 1) { + Utf8 charSequence194; + Object oldString194 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(194); + if (oldString194 instanceof Utf8) { + charSequence194 = (decoder).readString(((Utf8) oldString194)); + } else { + charSequence194 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(194, charSequence194); + } else { + throw new RuntimeException(("Illegal union index for 'F194': "+ unionIndex194)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema97(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex195 = (decoder.readIndex()); + if (unionIndex195 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(195, null); + } else { + if (unionIndex195 == 1) { + Utf8 charSequence195; + Object oldString195 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(195); + if (oldString195 instanceof Utf8) { + charSequence195 = (decoder).readString(((Utf8) oldString195)); + } else { + charSequence195 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(195, charSequence195); + } else { + throw new RuntimeException(("Illegal union index for 'F195': "+ unionIndex195)); + } + } + int unionIndex196 = (decoder.readIndex()); + if (unionIndex196 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(196, null); + } else { + if (unionIndex196 == 1) { + Utf8 charSequence196; + Object oldString196 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(196); + if (oldString196 instanceof Utf8) { + charSequence196 = (decoder).readString(((Utf8) oldString196)); + } else { + charSequence196 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(196, charSequence196); + } else { + throw new RuntimeException(("Illegal union index for 'F196': "+ unionIndex196)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema98(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex197 = (decoder.readIndex()); + if (unionIndex197 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(197, null); + } else { + if (unionIndex197 == 1) { + Utf8 charSequence197; + Object oldString197 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(197); + if (oldString197 instanceof Utf8) { + charSequence197 = (decoder).readString(((Utf8) oldString197)); + } else { + charSequence197 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(197, charSequence197); + } else { + throw new RuntimeException(("Illegal union index for 'F197': "+ unionIndex197)); + } + } + int unionIndex198 = (decoder.readIndex()); + if (unionIndex198 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(198, null); + } else { + if (unionIndex198 == 1) { + Utf8 charSequence198; + Object oldString198 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(198); + if (oldString198 instanceof Utf8) { + charSequence198 = (decoder).readString(((Utf8) oldString198)); + } else { + charSequence198 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(198, charSequence198); + } else { + throw new RuntimeException(("Illegal union index for 'F198': "+ unionIndex198)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema99(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex199 = (decoder.readIndex()); + if (unionIndex199 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(199, null); + } else { + if (unionIndex199 == 1) { + Utf8 charSequence199; + Object oldString199 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(199); + if (oldString199 instanceof Utf8) { + charSequence199 = (decoder).readString(((Utf8) oldString199)); + } else { + charSequence199 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(199, charSequence199); + } else { + throw new RuntimeException(("Illegal union index for 'F199': "+ unionIndex199)); + } + } + int unionIndex200 = (decoder.readIndex()); + if (unionIndex200 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(200, null); + } else { + if (unionIndex200 == 1) { + Utf8 charSequence200; + Object oldString200 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(200); + if (oldString200 instanceof Utf8) { + charSequence200 = (decoder).readString(((Utf8) oldString200)); + } else { + charSequence200 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(200, charSequence200); + } else { + throw new RuntimeException(("Illegal union index for 'F200': "+ unionIndex200)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema100(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex201 = (decoder.readIndex()); + if (unionIndex201 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(201, null); + } else { + if (unionIndex201 == 1) { + Utf8 charSequence201; + Object oldString201 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(201); + if (oldString201 instanceof Utf8) { + charSequence201 = (decoder).readString(((Utf8) oldString201)); + } else { + charSequence201 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(201, charSequence201); + } else { + throw new RuntimeException(("Illegal union index for 'F201': "+ unionIndex201)); + } + } + int unionIndex202 = (decoder.readIndex()); + if (unionIndex202 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(202, null); + } else { + if (unionIndex202 == 1) { + Utf8 charSequence202; + Object oldString202 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(202); + if (oldString202 instanceof Utf8) { + charSequence202 = (decoder).readString(((Utf8) oldString202)); + } else { + charSequence202 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(202, charSequence202); + } else { + throw new RuntimeException(("Illegal union index for 'F202': "+ unionIndex202)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema101(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex203 = (decoder.readIndex()); + if (unionIndex203 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(203, null); + } else { + if (unionIndex203 == 1) { + Utf8 charSequence203; + Object oldString203 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(203); + if (oldString203 instanceof Utf8) { + charSequence203 = (decoder).readString(((Utf8) oldString203)); + } else { + charSequence203 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(203, charSequence203); + } else { + throw new RuntimeException(("Illegal union index for 'F203': "+ unionIndex203)); + } + } + int unionIndex204 = (decoder.readIndex()); + if (unionIndex204 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(204, null); + } else { + if (unionIndex204 == 1) { + Utf8 charSequence204; + Object oldString204 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(204); + if (oldString204 instanceof Utf8) { + charSequence204 = (decoder).readString(((Utf8) oldString204)); + } else { + charSequence204 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(204, charSequence204); + } else { + throw new RuntimeException(("Illegal union index for 'F204': "+ unionIndex204)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema102(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex205 = (decoder.readIndex()); + if (unionIndex205 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(205, null); + } else { + if (unionIndex205 == 1) { + Utf8 charSequence205; + Object oldString205 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(205); + if (oldString205 instanceof Utf8) { + charSequence205 = (decoder).readString(((Utf8) oldString205)); + } else { + charSequence205 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(205, charSequence205); + } else { + throw new RuntimeException(("Illegal union index for 'F205': "+ unionIndex205)); + } + } + int unionIndex206 = (decoder.readIndex()); + if (unionIndex206 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(206, null); + } else { + if (unionIndex206 == 1) { + Utf8 charSequence206; + Object oldString206 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(206); + if (oldString206 instanceof Utf8) { + charSequence206 = (decoder).readString(((Utf8) oldString206)); + } else { + charSequence206 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(206, charSequence206); + } else { + throw new RuntimeException(("Illegal union index for 'F206': "+ unionIndex206)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema103(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex207 = (decoder.readIndex()); + if (unionIndex207 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(207, null); + } else { + if (unionIndex207 == 1) { + Utf8 charSequence207; + Object oldString207 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(207); + if (oldString207 instanceof Utf8) { + charSequence207 = (decoder).readString(((Utf8) oldString207)); + } else { + charSequence207 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(207, charSequence207); + } else { + throw new RuntimeException(("Illegal union index for 'F207': "+ unionIndex207)); + } + } + int unionIndex208 = (decoder.readIndex()); + if (unionIndex208 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(208, null); + } else { + if (unionIndex208 == 1) { + Utf8 charSequence208; + Object oldString208 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(208); + if (oldString208 instanceof Utf8) { + charSequence208 = (decoder).readString(((Utf8) oldString208)); + } else { + charSequence208 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(208, charSequence208); + } else { + throw new RuntimeException(("Illegal union index for 'F208': "+ unionIndex208)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema104(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex209 = (decoder.readIndex()); + if (unionIndex209 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(209, null); + } else { + if (unionIndex209 == 1) { + Utf8 charSequence209; + Object oldString209 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(209); + if (oldString209 instanceof Utf8) { + charSequence209 = (decoder).readString(((Utf8) oldString209)); + } else { + charSequence209 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(209, charSequence209); + } else { + throw new RuntimeException(("Illegal union index for 'F209': "+ unionIndex209)); + } + } + int unionIndex210 = (decoder.readIndex()); + if (unionIndex210 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(210, null); + } else { + if (unionIndex210 == 1) { + Utf8 charSequence210; + Object oldString210 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(210); + if (oldString210 instanceof Utf8) { + charSequence210 = (decoder).readString(((Utf8) oldString210)); + } else { + charSequence210 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(210, charSequence210); + } else { + throw new RuntimeException(("Illegal union index for 'F210': "+ unionIndex210)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema105(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex211 = (decoder.readIndex()); + if (unionIndex211 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(211, null); + } else { + if (unionIndex211 == 1) { + Utf8 charSequence211; + Object oldString211 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(211); + if (oldString211 instanceof Utf8) { + charSequence211 = (decoder).readString(((Utf8) oldString211)); + } else { + charSequence211 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(211, charSequence211); + } else { + throw new RuntimeException(("Illegal union index for 'F211': "+ unionIndex211)); + } + } + int unionIndex212 = (decoder.readIndex()); + if (unionIndex212 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(212, null); + } else { + if (unionIndex212 == 1) { + Utf8 charSequence212; + Object oldString212 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(212); + if (oldString212 instanceof Utf8) { + charSequence212 = (decoder).readString(((Utf8) oldString212)); + } else { + charSequence212 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(212, charSequence212); + } else { + throw new RuntimeException(("Illegal union index for 'F212': "+ unionIndex212)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema106(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex213 = (decoder.readIndex()); + if (unionIndex213 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(213, null); + } else { + if (unionIndex213 == 1) { + Utf8 charSequence213; + Object oldString213 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(213); + if (oldString213 instanceof Utf8) { + charSequence213 = (decoder).readString(((Utf8) oldString213)); + } else { + charSequence213 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(213, charSequence213); + } else { + throw new RuntimeException(("Illegal union index for 'F213': "+ unionIndex213)); + } + } + int unionIndex214 = (decoder.readIndex()); + if (unionIndex214 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(214, null); + } else { + if (unionIndex214 == 1) { + Utf8 charSequence214; + Object oldString214 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(214); + if (oldString214 instanceof Utf8) { + charSequence214 = (decoder).readString(((Utf8) oldString214)); + } else { + charSequence214 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(214, charSequence214); + } else { + throw new RuntimeException(("Illegal union index for 'F214': "+ unionIndex214)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema107(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex215 = (decoder.readIndex()); + if (unionIndex215 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(215, null); + } else { + if (unionIndex215 == 1) { + Utf8 charSequence215; + Object oldString215 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(215); + if (oldString215 instanceof Utf8) { + charSequence215 = (decoder).readString(((Utf8) oldString215)); + } else { + charSequence215 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(215, charSequence215); + } else { + throw new RuntimeException(("Illegal union index for 'F215': "+ unionIndex215)); + } + } + int unionIndex216 = (decoder.readIndex()); + if (unionIndex216 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(216, null); + } else { + if (unionIndex216 == 1) { + Utf8 charSequence216; + Object oldString216 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(216); + if (oldString216 instanceof Utf8) { + charSequence216 = (decoder).readString(((Utf8) oldString216)); + } else { + charSequence216 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(216, charSequence216); + } else { + throw new RuntimeException(("Illegal union index for 'F216': "+ unionIndex216)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema108(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex217 = (decoder.readIndex()); + if (unionIndex217 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(217, null); + } else { + if (unionIndex217 == 1) { + Utf8 charSequence217; + Object oldString217 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(217); + if (oldString217 instanceof Utf8) { + charSequence217 = (decoder).readString(((Utf8) oldString217)); + } else { + charSequence217 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(217, charSequence217); + } else { + throw new RuntimeException(("Illegal union index for 'F217': "+ unionIndex217)); + } + } + int unionIndex218 = (decoder.readIndex()); + if (unionIndex218 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(218, null); + } else { + if (unionIndex218 == 1) { + Utf8 charSequence218; + Object oldString218 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(218); + if (oldString218 instanceof Utf8) { + charSequence218 = (decoder).readString(((Utf8) oldString218)); + } else { + charSequence218 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(218, charSequence218); + } else { + throw new RuntimeException(("Illegal union index for 'F218': "+ unionIndex218)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema109(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex219 = (decoder.readIndex()); + if (unionIndex219 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(219, null); + } else { + if (unionIndex219 == 1) { + Utf8 charSequence219; + Object oldString219 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(219); + if (oldString219 instanceof Utf8) { + charSequence219 = (decoder).readString(((Utf8) oldString219)); + } else { + charSequence219 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(219, charSequence219); + } else { + throw new RuntimeException(("Illegal union index for 'F219': "+ unionIndex219)); + } + } + int unionIndex220 = (decoder.readIndex()); + if (unionIndex220 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(220, null); + } else { + if (unionIndex220 == 1) { + Utf8 charSequence220; + Object oldString220 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(220); + if (oldString220 instanceof Utf8) { + charSequence220 = (decoder).readString(((Utf8) oldString220)); + } else { + charSequence220 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(220, charSequence220); + } else { + throw new RuntimeException(("Illegal union index for 'F220': "+ unionIndex220)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema110(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex221 = (decoder.readIndex()); + if (unionIndex221 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(221, null); + } else { + if (unionIndex221 == 1) { + Utf8 charSequence221; + Object oldString221 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(221); + if (oldString221 instanceof Utf8) { + charSequence221 = (decoder).readString(((Utf8) oldString221)); + } else { + charSequence221 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(221, charSequence221); + } else { + throw new RuntimeException(("Illegal union index for 'F221': "+ unionIndex221)); + } + } + int unionIndex222 = (decoder.readIndex()); + if (unionIndex222 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(222, null); + } else { + if (unionIndex222 == 1) { + Utf8 charSequence222; + Object oldString222 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(222); + if (oldString222 instanceof Utf8) { + charSequence222 = (decoder).readString(((Utf8) oldString222)); + } else { + charSequence222 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(222, charSequence222); + } else { + throw new RuntimeException(("Illegal union index for 'F222': "+ unionIndex222)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema111(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex223 = (decoder.readIndex()); + if (unionIndex223 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(223, null); + } else { + if (unionIndex223 == 1) { + Utf8 charSequence223; + Object oldString223 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(223); + if (oldString223 instanceof Utf8) { + charSequence223 = (decoder).readString(((Utf8) oldString223)); + } else { + charSequence223 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(223, charSequence223); + } else { + throw new RuntimeException(("Illegal union index for 'F223': "+ unionIndex223)); + } + } + int unionIndex224 = (decoder.readIndex()); + if (unionIndex224 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(224, null); + } else { + if (unionIndex224 == 1) { + Utf8 charSequence224; + Object oldString224 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(224); + if (oldString224 instanceof Utf8) { + charSequence224 = (decoder).readString(((Utf8) oldString224)); + } else { + charSequence224 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(224, charSequence224); + } else { + throw new RuntimeException(("Illegal union index for 'F224': "+ unionIndex224)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema112(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex225 = (decoder.readIndex()); + if (unionIndex225 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(225, null); + } else { + if (unionIndex225 == 1) { + Utf8 charSequence225; + Object oldString225 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(225); + if (oldString225 instanceof Utf8) { + charSequence225 = (decoder).readString(((Utf8) oldString225)); + } else { + charSequence225 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(225, charSequence225); + } else { + throw new RuntimeException(("Illegal union index for 'F225': "+ unionIndex225)); + } + } + int unionIndex226 = (decoder.readIndex()); + if (unionIndex226 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(226, null); + } else { + if (unionIndex226 == 1) { + Utf8 charSequence226; + Object oldString226 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(226); + if (oldString226 instanceof Utf8) { + charSequence226 = (decoder).readString(((Utf8) oldString226)); + } else { + charSequence226 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(226, charSequence226); + } else { + throw new RuntimeException(("Illegal union index for 'F226': "+ unionIndex226)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema113(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex227 = (decoder.readIndex()); + if (unionIndex227 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(227, null); + } else { + if (unionIndex227 == 1) { + Utf8 charSequence227; + Object oldString227 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(227); + if (oldString227 instanceof Utf8) { + charSequence227 = (decoder).readString(((Utf8) oldString227)); + } else { + charSequence227 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(227, charSequence227); + } else { + throw new RuntimeException(("Illegal union index for 'F227': "+ unionIndex227)); + } + } + int unionIndex228 = (decoder.readIndex()); + if (unionIndex228 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(228, null); + } else { + if (unionIndex228 == 1) { + Utf8 charSequence228; + Object oldString228 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(228); + if (oldString228 instanceof Utf8) { + charSequence228 = (decoder).readString(((Utf8) oldString228)); + } else { + charSequence228 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(228, charSequence228); + } else { + throw new RuntimeException(("Illegal union index for 'F228': "+ unionIndex228)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema114(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex229 = (decoder.readIndex()); + if (unionIndex229 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(229, null); + } else { + if (unionIndex229 == 1) { + Utf8 charSequence229; + Object oldString229 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(229); + if (oldString229 instanceof Utf8) { + charSequence229 = (decoder).readString(((Utf8) oldString229)); + } else { + charSequence229 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(229, charSequence229); + } else { + throw new RuntimeException(("Illegal union index for 'F229': "+ unionIndex229)); + } + } + int unionIndex230 = (decoder.readIndex()); + if (unionIndex230 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(230, null); + } else { + if (unionIndex230 == 1) { + Utf8 charSequence230; + Object oldString230 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(230); + if (oldString230 instanceof Utf8) { + charSequence230 = (decoder).readString(((Utf8) oldString230)); + } else { + charSequence230 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(230, charSequence230); + } else { + throw new RuntimeException(("Illegal union index for 'F230': "+ unionIndex230)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema115(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex231 = (decoder.readIndex()); + if (unionIndex231 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(231, null); + } else { + if (unionIndex231 == 1) { + Utf8 charSequence231; + Object oldString231 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(231); + if (oldString231 instanceof Utf8) { + charSequence231 = (decoder).readString(((Utf8) oldString231)); + } else { + charSequence231 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(231, charSequence231); + } else { + throw new RuntimeException(("Illegal union index for 'F231': "+ unionIndex231)); + } + } + int unionIndex232 = (decoder.readIndex()); + if (unionIndex232 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(232, null); + } else { + if (unionIndex232 == 1) { + Utf8 charSequence232; + Object oldString232 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(232); + if (oldString232 instanceof Utf8) { + charSequence232 = (decoder).readString(((Utf8) oldString232)); + } else { + charSequence232 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(232, charSequence232); + } else { + throw new RuntimeException(("Illegal union index for 'F232': "+ unionIndex232)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema116(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex233 = (decoder.readIndex()); + if (unionIndex233 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(233, null); + } else { + if (unionIndex233 == 1) { + Utf8 charSequence233; + Object oldString233 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(233); + if (oldString233 instanceof Utf8) { + charSequence233 = (decoder).readString(((Utf8) oldString233)); + } else { + charSequence233 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(233, charSequence233); + } else { + throw new RuntimeException(("Illegal union index for 'F233': "+ unionIndex233)); + } + } + int unionIndex234 = (decoder.readIndex()); + if (unionIndex234 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(234, null); + } else { + if (unionIndex234 == 1) { + Utf8 charSequence234; + Object oldString234 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(234); + if (oldString234 instanceof Utf8) { + charSequence234 = (decoder).readString(((Utf8) oldString234)); + } else { + charSequence234 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(234, charSequence234); + } else { + throw new RuntimeException(("Illegal union index for 'F234': "+ unionIndex234)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema117(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex235 = (decoder.readIndex()); + if (unionIndex235 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(235, null); + } else { + if (unionIndex235 == 1) { + Utf8 charSequence235; + Object oldString235 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(235); + if (oldString235 instanceof Utf8) { + charSequence235 = (decoder).readString(((Utf8) oldString235)); + } else { + charSequence235 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(235, charSequence235); + } else { + throw new RuntimeException(("Illegal union index for 'F235': "+ unionIndex235)); + } + } + int unionIndex236 = (decoder.readIndex()); + if (unionIndex236 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(236, null); + } else { + if (unionIndex236 == 1) { + Utf8 charSequence236; + Object oldString236 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(236); + if (oldString236 instanceof Utf8) { + charSequence236 = (decoder).readString(((Utf8) oldString236)); + } else { + charSequence236 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(236, charSequence236); + } else { + throw new RuntimeException(("Illegal union index for 'F236': "+ unionIndex236)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema118(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex237 = (decoder.readIndex()); + if (unionIndex237 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(237, null); + } else { + if (unionIndex237 == 1) { + Utf8 charSequence237; + Object oldString237 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(237); + if (oldString237 instanceof Utf8) { + charSequence237 = (decoder).readString(((Utf8) oldString237)); + } else { + charSequence237 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(237, charSequence237); + } else { + throw new RuntimeException(("Illegal union index for 'F237': "+ unionIndex237)); + } + } + int unionIndex238 = (decoder.readIndex()); + if (unionIndex238 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(238, null); + } else { + if (unionIndex238 == 1) { + Utf8 charSequence238; + Object oldString238 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(238); + if (oldString238 instanceof Utf8) { + charSequence238 = (decoder).readString(((Utf8) oldString238)); + } else { + charSequence238 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(238, charSequence238); + } else { + throw new RuntimeException(("Illegal union index for 'F238': "+ unionIndex238)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema119(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex239 = (decoder.readIndex()); + if (unionIndex239 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(239, null); + } else { + if (unionIndex239 == 1) { + Utf8 charSequence239; + Object oldString239 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(239); + if (oldString239 instanceof Utf8) { + charSequence239 = (decoder).readString(((Utf8) oldString239)); + } else { + charSequence239 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(239, charSequence239); + } else { + throw new RuntimeException(("Illegal union index for 'F239': "+ unionIndex239)); + } + } + int unionIndex240 = (decoder.readIndex()); + if (unionIndex240 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(240, null); + } else { + if (unionIndex240 == 1) { + Utf8 charSequence240; + Object oldString240 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(240); + if (oldString240 instanceof Utf8) { + charSequence240 = (decoder).readString(((Utf8) oldString240)); + } else { + charSequence240 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(240, charSequence240); + } else { + throw new RuntimeException(("Illegal union index for 'F240': "+ unionIndex240)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema120(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex241 = (decoder.readIndex()); + if (unionIndex241 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(241, null); + } else { + if (unionIndex241 == 1) { + Utf8 charSequence241; + Object oldString241 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(241); + if (oldString241 instanceof Utf8) { + charSequence241 = (decoder).readString(((Utf8) oldString241)); + } else { + charSequence241 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(241, charSequence241); + } else { + throw new RuntimeException(("Illegal union index for 'F241': "+ unionIndex241)); + } + } + int unionIndex242 = (decoder.readIndex()); + if (unionIndex242 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(242, null); + } else { + if (unionIndex242 == 1) { + Utf8 charSequence242; + Object oldString242 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(242); + if (oldString242 instanceof Utf8) { + charSequence242 = (decoder).readString(((Utf8) oldString242)); + } else { + charSequence242 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(242, charSequence242); + } else { + throw new RuntimeException(("Illegal union index for 'F242': "+ unionIndex242)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema121(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex243 = (decoder.readIndex()); + if (unionIndex243 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(243, null); + } else { + if (unionIndex243 == 1) { + Utf8 charSequence243; + Object oldString243 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(243); + if (oldString243 instanceof Utf8) { + charSequence243 = (decoder).readString(((Utf8) oldString243)); + } else { + charSequence243 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(243, charSequence243); + } else { + throw new RuntimeException(("Illegal union index for 'F243': "+ unionIndex243)); + } + } + int unionIndex244 = (decoder.readIndex()); + if (unionIndex244 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(244, null); + } else { + if (unionIndex244 == 1) { + Utf8 charSequence244; + Object oldString244 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(244); + if (oldString244 instanceof Utf8) { + charSequence244 = (decoder).readString(((Utf8) oldString244)); + } else { + charSequence244 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(244, charSequence244); + } else { + throw new RuntimeException(("Illegal union index for 'F244': "+ unionIndex244)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema122(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex245 = (decoder.readIndex()); + if (unionIndex245 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(245, null); + } else { + if (unionIndex245 == 1) { + Utf8 charSequence245; + Object oldString245 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(245); + if (oldString245 instanceof Utf8) { + charSequence245 = (decoder).readString(((Utf8) oldString245)); + } else { + charSequence245 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(245, charSequence245); + } else { + throw new RuntimeException(("Illegal union index for 'F245': "+ unionIndex245)); + } + } + int unionIndex246 = (decoder.readIndex()); + if (unionIndex246 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(246, null); + } else { + if (unionIndex246 == 1) { + Utf8 charSequence246; + Object oldString246 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(246); + if (oldString246 instanceof Utf8) { + charSequence246 = (decoder).readString(((Utf8) oldString246)); + } else { + charSequence246 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(246, charSequence246); + } else { + throw new RuntimeException(("Illegal union index for 'F246': "+ unionIndex246)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema123(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex247 = (decoder.readIndex()); + if (unionIndex247 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(247, null); + } else { + if (unionIndex247 == 1) { + Utf8 charSequence247; + Object oldString247 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(247); + if (oldString247 instanceof Utf8) { + charSequence247 = (decoder).readString(((Utf8) oldString247)); + } else { + charSequence247 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(247, charSequence247); + } else { + throw new RuntimeException(("Illegal union index for 'F247': "+ unionIndex247)); + } + } + int unionIndex248 = (decoder.readIndex()); + if (unionIndex248 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(248, null); + } else { + if (unionIndex248 == 1) { + Utf8 charSequence248; + Object oldString248 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(248); + if (oldString248 instanceof Utf8) { + charSequence248 = (decoder).readString(((Utf8) oldString248)); + } else { + charSequence248 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(248, charSequence248); + } else { + throw new RuntimeException(("Illegal union index for 'F248': "+ unionIndex248)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema124(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex249 = (decoder.readIndex()); + if (unionIndex249 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(249, null); + } else { + if (unionIndex249 == 1) { + Utf8 charSequence249; + Object oldString249 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(249); + if (oldString249 instanceof Utf8) { + charSequence249 = (decoder).readString(((Utf8) oldString249)); + } else { + charSequence249 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(249, charSequence249); + } else { + throw new RuntimeException(("Illegal union index for 'F249': "+ unionIndex249)); + } + } + int unionIndex250 = (decoder.readIndex()); + if (unionIndex250 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(250, null); + } else { + if (unionIndex250 == 1) { + Utf8 charSequence250; + Object oldString250 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(250); + if (oldString250 instanceof Utf8) { + charSequence250 = (decoder).readString(((Utf8) oldString250)); + } else { + charSequence250 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(250, charSequence250); + } else { + throw new RuntimeException(("Illegal union index for 'F250': "+ unionIndex250)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema125(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex251 = (decoder.readIndex()); + if (unionIndex251 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(251, null); + } else { + if (unionIndex251 == 1) { + Utf8 charSequence251; + Object oldString251 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(251); + if (oldString251 instanceof Utf8) { + charSequence251 = (decoder).readString(((Utf8) oldString251)); + } else { + charSequence251 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(251, charSequence251); + } else { + throw new RuntimeException(("Illegal union index for 'F251': "+ unionIndex251)); + } + } + int unionIndex252 = (decoder.readIndex()); + if (unionIndex252 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(252, null); + } else { + if (unionIndex252 == 1) { + Utf8 charSequence252; + Object oldString252 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(252); + if (oldString252 instanceof Utf8) { + charSequence252 = (decoder).readString(((Utf8) oldString252)); + } else { + charSequence252 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(252, charSequence252); + } else { + throw new RuntimeException(("Illegal union index for 'F252': "+ unionIndex252)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema126(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex253 = (decoder.readIndex()); + if (unionIndex253 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(253, null); + } else { + if (unionIndex253 == 1) { + Utf8 charSequence253; + Object oldString253 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(253); + if (oldString253 instanceof Utf8) { + charSequence253 = (decoder).readString(((Utf8) oldString253)); + } else { + charSequence253 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(253, charSequence253); + } else { + throw new RuntimeException(("Illegal union index for 'F253': "+ unionIndex253)); + } + } + int unionIndex254 = (decoder.readIndex()); + if (unionIndex254 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(254, null); + } else { + if (unionIndex254 == 1) { + Utf8 charSequence254; + Object oldString254 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(254); + if (oldString254 instanceof Utf8) { + charSequence254 = (decoder).readString(((Utf8) oldString254)); + } else { + charSequence254 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(254, charSequence254); + } else { + throw new RuntimeException(("Illegal union index for 'F254': "+ unionIndex254)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema127(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex255 = (decoder.readIndex()); + if (unionIndex255 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(255, null); + } else { + if (unionIndex255 == 1) { + Utf8 charSequence255; + Object oldString255 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(255); + if (oldString255 instanceof Utf8) { + charSequence255 = (decoder).readString(((Utf8) oldString255)); + } else { + charSequence255 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(255, charSequence255); + } else { + throw new RuntimeException(("Illegal union index for 'F255': "+ unionIndex255)); + } + } + int unionIndex256 = (decoder.readIndex()); + if (unionIndex256 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(256, null); + } else { + if (unionIndex256 == 1) { + Utf8 charSequence256; + Object oldString256 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(256); + if (oldString256 instanceof Utf8) { + charSequence256 = (decoder).readString(((Utf8) oldString256)); + } else { + charSequence256 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(256, charSequence256); + } else { + throw new RuntimeException(("Illegal union index for 'F256': "+ unionIndex256)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema128(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex257 = (decoder.readIndex()); + if (unionIndex257 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(257, null); + } else { + if (unionIndex257 == 1) { + Utf8 charSequence257; + Object oldString257 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(257); + if (oldString257 instanceof Utf8) { + charSequence257 = (decoder).readString(((Utf8) oldString257)); + } else { + charSequence257 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(257, charSequence257); + } else { + throw new RuntimeException(("Illegal union index for 'F257': "+ unionIndex257)); + } + } + int unionIndex258 = (decoder.readIndex()); + if (unionIndex258 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(258, null); + } else { + if (unionIndex258 == 1) { + Utf8 charSequence258; + Object oldString258 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(258); + if (oldString258 instanceof Utf8) { + charSequence258 = (decoder).readString(((Utf8) oldString258)); + } else { + charSequence258 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(258, charSequence258); + } else { + throw new RuntimeException(("Illegal union index for 'F258': "+ unionIndex258)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema129(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex259 = (decoder.readIndex()); + if (unionIndex259 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(259, null); + } else { + if (unionIndex259 == 1) { + Utf8 charSequence259; + Object oldString259 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(259); + if (oldString259 instanceof Utf8) { + charSequence259 = (decoder).readString(((Utf8) oldString259)); + } else { + charSequence259 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(259, charSequence259); + } else { + throw new RuntimeException(("Illegal union index for 'F259': "+ unionIndex259)); + } + } + int unionIndex260 = (decoder.readIndex()); + if (unionIndex260 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(260, null); + } else { + if (unionIndex260 == 1) { + Utf8 charSequence260; + Object oldString260 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(260); + if (oldString260 instanceof Utf8) { + charSequence260 = (decoder).readString(((Utf8) oldString260)); + } else { + charSequence260 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(260, charSequence260); + } else { + throw new RuntimeException(("Illegal union index for 'F260': "+ unionIndex260)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema130(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex261 = (decoder.readIndex()); + if (unionIndex261 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(261, null); + } else { + if (unionIndex261 == 1) { + Utf8 charSequence261; + Object oldString261 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(261); + if (oldString261 instanceof Utf8) { + charSequence261 = (decoder).readString(((Utf8) oldString261)); + } else { + charSequence261 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(261, charSequence261); + } else { + throw new RuntimeException(("Illegal union index for 'F261': "+ unionIndex261)); + } + } + int unionIndex262 = (decoder.readIndex()); + if (unionIndex262 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(262, null); + } else { + if (unionIndex262 == 1) { + Utf8 charSequence262; + Object oldString262 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(262); + if (oldString262 instanceof Utf8) { + charSequence262 = (decoder).readString(((Utf8) oldString262)); + } else { + charSequence262 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(262, charSequence262); + } else { + throw new RuntimeException(("Illegal union index for 'F262': "+ unionIndex262)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema131(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex263 = (decoder.readIndex()); + if (unionIndex263 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(263, null); + } else { + if (unionIndex263 == 1) { + Utf8 charSequence263; + Object oldString263 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(263); + if (oldString263 instanceof Utf8) { + charSequence263 = (decoder).readString(((Utf8) oldString263)); + } else { + charSequence263 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(263, charSequence263); + } else { + throw new RuntimeException(("Illegal union index for 'F263': "+ unionIndex263)); + } + } + int unionIndex264 = (decoder.readIndex()); + if (unionIndex264 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(264, null); + } else { + if (unionIndex264 == 1) { + Utf8 charSequence264; + Object oldString264 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(264); + if (oldString264 instanceof Utf8) { + charSequence264 = (decoder).readString(((Utf8) oldString264)); + } else { + charSequence264 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(264, charSequence264); + } else { + throw new RuntimeException(("Illegal union index for 'F264': "+ unionIndex264)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema132(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex265 = (decoder.readIndex()); + if (unionIndex265 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(265, null); + } else { + if (unionIndex265 == 1) { + Utf8 charSequence265; + Object oldString265 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(265); + if (oldString265 instanceof Utf8) { + charSequence265 = (decoder).readString(((Utf8) oldString265)); + } else { + charSequence265 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(265, charSequence265); + } else { + throw new RuntimeException(("Illegal union index for 'F265': "+ unionIndex265)); + } + } + int unionIndex266 = (decoder.readIndex()); + if (unionIndex266 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(266, null); + } else { + if (unionIndex266 == 1) { + Utf8 charSequence266; + Object oldString266 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(266); + if (oldString266 instanceof Utf8) { + charSequence266 = (decoder).readString(((Utf8) oldString266)); + } else { + charSequence266 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(266, charSequence266); + } else { + throw new RuntimeException(("Illegal union index for 'F266': "+ unionIndex266)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema133(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex267 = (decoder.readIndex()); + if (unionIndex267 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(267, null); + } else { + if (unionIndex267 == 1) { + Utf8 charSequence267; + Object oldString267 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(267); + if (oldString267 instanceof Utf8) { + charSequence267 = (decoder).readString(((Utf8) oldString267)); + } else { + charSequence267 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(267, charSequence267); + } else { + throw new RuntimeException(("Illegal union index for 'F267': "+ unionIndex267)); + } + } + int unionIndex268 = (decoder.readIndex()); + if (unionIndex268 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(268, null); + } else { + if (unionIndex268 == 1) { + Utf8 charSequence268; + Object oldString268 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(268); + if (oldString268 instanceof Utf8) { + charSequence268 = (decoder).readString(((Utf8) oldString268)); + } else { + charSequence268 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(268, charSequence268); + } else { + throw new RuntimeException(("Illegal union index for 'F268': "+ unionIndex268)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema134(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex269 = (decoder.readIndex()); + if (unionIndex269 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(269, null); + } else { + if (unionIndex269 == 1) { + Utf8 charSequence269; + Object oldString269 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(269); + if (oldString269 instanceof Utf8) { + charSequence269 = (decoder).readString(((Utf8) oldString269)); + } else { + charSequence269 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(269, charSequence269); + } else { + throw new RuntimeException(("Illegal union index for 'F269': "+ unionIndex269)); + } + } + int unionIndex270 = (decoder.readIndex()); + if (unionIndex270 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(270, null); + } else { + if (unionIndex270 == 1) { + Utf8 charSequence270; + Object oldString270 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(270); + if (oldString270 instanceof Utf8) { + charSequence270 = (decoder).readString(((Utf8) oldString270)); + } else { + charSequence270 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(270, charSequence270); + } else { + throw new RuntimeException(("Illegal union index for 'F270': "+ unionIndex270)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema135(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex271 = (decoder.readIndex()); + if (unionIndex271 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(271, null); + } else { + if (unionIndex271 == 1) { + Utf8 charSequence271; + Object oldString271 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(271); + if (oldString271 instanceof Utf8) { + charSequence271 = (decoder).readString(((Utf8) oldString271)); + } else { + charSequence271 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(271, charSequence271); + } else { + throw new RuntimeException(("Illegal union index for 'F271': "+ unionIndex271)); + } + } + int unionIndex272 = (decoder.readIndex()); + if (unionIndex272 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(272, null); + } else { + if (unionIndex272 == 1) { + Utf8 charSequence272; + Object oldString272 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(272); + if (oldString272 instanceof Utf8) { + charSequence272 = (decoder).readString(((Utf8) oldString272)); + } else { + charSequence272 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(272, charSequence272); + } else { + throw new RuntimeException(("Illegal union index for 'F272': "+ unionIndex272)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema136(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex273 = (decoder.readIndex()); + if (unionIndex273 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(273, null); + } else { + if (unionIndex273 == 1) { + Utf8 charSequence273; + Object oldString273 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(273); + if (oldString273 instanceof Utf8) { + charSequence273 = (decoder).readString(((Utf8) oldString273)); + } else { + charSequence273 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(273, charSequence273); + } else { + throw new RuntimeException(("Illegal union index for 'F273': "+ unionIndex273)); + } + } + int unionIndex274 = (decoder.readIndex()); + if (unionIndex274 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(274, null); + } else { + if (unionIndex274 == 1) { + Utf8 charSequence274; + Object oldString274 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(274); + if (oldString274 instanceof Utf8) { + charSequence274 = (decoder).readString(((Utf8) oldString274)); + } else { + charSequence274 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(274, charSequence274); + } else { + throw new RuntimeException(("Illegal union index for 'F274': "+ unionIndex274)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema137(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex275 = (decoder.readIndex()); + if (unionIndex275 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(275, null); + } else { + if (unionIndex275 == 1) { + Utf8 charSequence275; + Object oldString275 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(275); + if (oldString275 instanceof Utf8) { + charSequence275 = (decoder).readString(((Utf8) oldString275)); + } else { + charSequence275 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(275, charSequence275); + } else { + throw new RuntimeException(("Illegal union index for 'F275': "+ unionIndex275)); + } + } + int unionIndex276 = (decoder.readIndex()); + if (unionIndex276 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(276, null); + } else { + if (unionIndex276 == 1) { + Utf8 charSequence276; + Object oldString276 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(276); + if (oldString276 instanceof Utf8) { + charSequence276 = (decoder).readString(((Utf8) oldString276)); + } else { + charSequence276 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(276, charSequence276); + } else { + throw new RuntimeException(("Illegal union index for 'F276': "+ unionIndex276)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema138(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex277 = (decoder.readIndex()); + if (unionIndex277 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(277, null); + } else { + if (unionIndex277 == 1) { + Utf8 charSequence277; + Object oldString277 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(277); + if (oldString277 instanceof Utf8) { + charSequence277 = (decoder).readString(((Utf8) oldString277)); + } else { + charSequence277 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(277, charSequence277); + } else { + throw new RuntimeException(("Illegal union index for 'F277': "+ unionIndex277)); + } + } + int unionIndex278 = (decoder.readIndex()); + if (unionIndex278 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(278, null); + } else { + if (unionIndex278 == 1) { + Utf8 charSequence278; + Object oldString278 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(278); + if (oldString278 instanceof Utf8) { + charSequence278 = (decoder).readString(((Utf8) oldString278)); + } else { + charSequence278 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(278, charSequence278); + } else { + throw new RuntimeException(("Illegal union index for 'F278': "+ unionIndex278)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema139(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex279 = (decoder.readIndex()); + if (unionIndex279 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(279, null); + } else { + if (unionIndex279 == 1) { + Utf8 charSequence279; + Object oldString279 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(279); + if (oldString279 instanceof Utf8) { + charSequence279 = (decoder).readString(((Utf8) oldString279)); + } else { + charSequence279 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(279, charSequence279); + } else { + throw new RuntimeException(("Illegal union index for 'F279': "+ unionIndex279)); + } + } + int unionIndex280 = (decoder.readIndex()); + if (unionIndex280 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(280, null); + } else { + if (unionIndex280 == 1) { + Utf8 charSequence280; + Object oldString280 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(280); + if (oldString280 instanceof Utf8) { + charSequence280 = (decoder).readString(((Utf8) oldString280)); + } else { + charSequence280 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(280, charSequence280); + } else { + throw new RuntimeException(("Illegal union index for 'F280': "+ unionIndex280)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema140(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex281 = (decoder.readIndex()); + if (unionIndex281 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(281, null); + } else { + if (unionIndex281 == 1) { + Utf8 charSequence281; + Object oldString281 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(281); + if (oldString281 instanceof Utf8) { + charSequence281 = (decoder).readString(((Utf8) oldString281)); + } else { + charSequence281 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(281, charSequence281); + } else { + throw new RuntimeException(("Illegal union index for 'F281': "+ unionIndex281)); + } + } + int unionIndex282 = (decoder.readIndex()); + if (unionIndex282 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(282, null); + } else { + if (unionIndex282 == 1) { + Utf8 charSequence282; + Object oldString282 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(282); + if (oldString282 instanceof Utf8) { + charSequence282 = (decoder).readString(((Utf8) oldString282)); + } else { + charSequence282 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(282, charSequence282); + } else { + throw new RuntimeException(("Illegal union index for 'F282': "+ unionIndex282)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema141(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex283 = (decoder.readIndex()); + if (unionIndex283 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(283, null); + } else { + if (unionIndex283 == 1) { + Utf8 charSequence283; + Object oldString283 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(283); + if (oldString283 instanceof Utf8) { + charSequence283 = (decoder).readString(((Utf8) oldString283)); + } else { + charSequence283 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(283, charSequence283); + } else { + throw new RuntimeException(("Illegal union index for 'F283': "+ unionIndex283)); + } + } + int unionIndex284 = (decoder.readIndex()); + if (unionIndex284 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(284, null); + } else { + if (unionIndex284 == 1) { + Utf8 charSequence284; + Object oldString284 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(284); + if (oldString284 instanceof Utf8) { + charSequence284 = (decoder).readString(((Utf8) oldString284)); + } else { + charSequence284 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(284, charSequence284); + } else { + throw new RuntimeException(("Illegal union index for 'F284': "+ unionIndex284)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema142(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex285 = (decoder.readIndex()); + if (unionIndex285 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(285, null); + } else { + if (unionIndex285 == 1) { + Utf8 charSequence285; + Object oldString285 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(285); + if (oldString285 instanceof Utf8) { + charSequence285 = (decoder).readString(((Utf8) oldString285)); + } else { + charSequence285 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(285, charSequence285); + } else { + throw new RuntimeException(("Illegal union index for 'F285': "+ unionIndex285)); + } + } + int unionIndex286 = (decoder.readIndex()); + if (unionIndex286 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(286, null); + } else { + if (unionIndex286 == 1) { + Utf8 charSequence286; + Object oldString286 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(286); + if (oldString286 instanceof Utf8) { + charSequence286 = (decoder).readString(((Utf8) oldString286)); + } else { + charSequence286 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(286, charSequence286); + } else { + throw new RuntimeException(("Illegal union index for 'F286': "+ unionIndex286)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema143(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex287 = (decoder.readIndex()); + if (unionIndex287 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(287, null); + } else { + if (unionIndex287 == 1) { + Utf8 charSequence287; + Object oldString287 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(287); + if (oldString287 instanceof Utf8) { + charSequence287 = (decoder).readString(((Utf8) oldString287)); + } else { + charSequence287 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(287, charSequence287); + } else { + throw new RuntimeException(("Illegal union index for 'F287': "+ unionIndex287)); + } + } + int unionIndex288 = (decoder.readIndex()); + if (unionIndex288 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(288, null); + } else { + if (unionIndex288 == 1) { + Utf8 charSequence288; + Object oldString288 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(288); + if (oldString288 instanceof Utf8) { + charSequence288 = (decoder).readString(((Utf8) oldString288)); + } else { + charSequence288 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(288, charSequence288); + } else { + throw new RuntimeException(("Illegal union index for 'F288': "+ unionIndex288)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema144(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex289 = (decoder.readIndex()); + if (unionIndex289 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(289, null); + } else { + if (unionIndex289 == 1) { + Utf8 charSequence289; + Object oldString289 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(289); + if (oldString289 instanceof Utf8) { + charSequence289 = (decoder).readString(((Utf8) oldString289)); + } else { + charSequence289 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(289, charSequence289); + } else { + throw new RuntimeException(("Illegal union index for 'F289': "+ unionIndex289)); + } + } + int unionIndex290 = (decoder.readIndex()); + if (unionIndex290 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(290, null); + } else { + if (unionIndex290 == 1) { + Utf8 charSequence290; + Object oldString290 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(290); + if (oldString290 instanceof Utf8) { + charSequence290 = (decoder).readString(((Utf8) oldString290)); + } else { + charSequence290 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(290, charSequence290); + } else { + throw new RuntimeException(("Illegal union index for 'F290': "+ unionIndex290)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema145(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex291 = (decoder.readIndex()); + if (unionIndex291 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(291, null); + } else { + if (unionIndex291 == 1) { + Utf8 charSequence291; + Object oldString291 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(291); + if (oldString291 instanceof Utf8) { + charSequence291 = (decoder).readString(((Utf8) oldString291)); + } else { + charSequence291 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(291, charSequence291); + } else { + throw new RuntimeException(("Illegal union index for 'F291': "+ unionIndex291)); + } + } + int unionIndex292 = (decoder.readIndex()); + if (unionIndex292 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(292, null); + } else { + if (unionIndex292 == 1) { + Utf8 charSequence292; + Object oldString292 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(292); + if (oldString292 instanceof Utf8) { + charSequence292 = (decoder).readString(((Utf8) oldString292)); + } else { + charSequence292 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(292, charSequence292); + } else { + throw new RuntimeException(("Illegal union index for 'F292': "+ unionIndex292)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema146(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex293 = (decoder.readIndex()); + if (unionIndex293 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(293, null); + } else { + if (unionIndex293 == 1) { + Utf8 charSequence293; + Object oldString293 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(293); + if (oldString293 instanceof Utf8) { + charSequence293 = (decoder).readString(((Utf8) oldString293)); + } else { + charSequence293 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(293, charSequence293); + } else { + throw new RuntimeException(("Illegal union index for 'F293': "+ unionIndex293)); + } + } + int unionIndex294 = (decoder.readIndex()); + if (unionIndex294 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(294, null); + } else { + if (unionIndex294 == 1) { + Utf8 charSequence294; + Object oldString294 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(294); + if (oldString294 instanceof Utf8) { + charSequence294 = (decoder).readString(((Utf8) oldString294)); + } else { + charSequence294 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(294, charSequence294); + } else { + throw new RuntimeException(("Illegal union index for 'F294': "+ unionIndex294)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema147(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex295 = (decoder.readIndex()); + if (unionIndex295 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(295, null); + } else { + if (unionIndex295 == 1) { + Utf8 charSequence295; + Object oldString295 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(295); + if (oldString295 instanceof Utf8) { + charSequence295 = (decoder).readString(((Utf8) oldString295)); + } else { + charSequence295 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(295, charSequence295); + } else { + throw new RuntimeException(("Illegal union index for 'F295': "+ unionIndex295)); + } + } + int unionIndex296 = (decoder.readIndex()); + if (unionIndex296 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(296, null); + } else { + if (unionIndex296 == 1) { + Utf8 charSequence296; + Object oldString296 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(296); + if (oldString296 instanceof Utf8) { + charSequence296 = (decoder).readString(((Utf8) oldString296)); + } else { + charSequence296 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(296, charSequence296); + } else { + throw new RuntimeException(("Illegal union index for 'F296': "+ unionIndex296)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema148(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex297 = (decoder.readIndex()); + if (unionIndex297 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(297, null); + } else { + if (unionIndex297 == 1) { + Utf8 charSequence297; + Object oldString297 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(297); + if (oldString297 instanceof Utf8) { + charSequence297 = (decoder).readString(((Utf8) oldString297)); + } else { + charSequence297 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(297, charSequence297); + } else { + throw new RuntimeException(("Illegal union index for 'F297': "+ unionIndex297)); + } + } + int unionIndex298 = (decoder.readIndex()); + if (unionIndex298 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(298, null); + } else { + if (unionIndex298 == 1) { + Utf8 charSequence298; + Object oldString298 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(298); + if (oldString298 instanceof Utf8) { + charSequence298 = (decoder).readString(((Utf8) oldString298)); + } else { + charSequence298 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(298, charSequence298); + } else { + throw new RuntimeException(("Illegal union index for 'F298': "+ unionIndex298)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema149(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex299 = (decoder.readIndex()); + if (unionIndex299 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(299, null); + } else { + if (unionIndex299 == 1) { + Utf8 charSequence299; + Object oldString299 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(299); + if (oldString299 instanceof Utf8) { + charSequence299 = (decoder).readString(((Utf8) oldString299)); + } else { + charSequence299 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(299, charSequence299); + } else { + throw new RuntimeException(("Illegal union index for 'F299': "+ unionIndex299)); + } + } + int unionIndex300 = (decoder.readIndex()); + if (unionIndex300 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(300, null); + } else { + if (unionIndex300 == 1) { + Utf8 charSequence300; + Object oldString300 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(300); + if (oldString300 instanceof Utf8) { + charSequence300 = (decoder).readString(((Utf8) oldString300)); + } else { + charSequence300 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(300, charSequence300); + } else { + throw new RuntimeException(("Illegal union index for 'F300': "+ unionIndex300)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema150(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex301 = (decoder.readIndex()); + if (unionIndex301 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(301, null); + } else { + if (unionIndex301 == 1) { + Utf8 charSequence301; + Object oldString301 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(301); + if (oldString301 instanceof Utf8) { + charSequence301 = (decoder).readString(((Utf8) oldString301)); + } else { + charSequence301 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(301, charSequence301); + } else { + throw new RuntimeException(("Illegal union index for 'F301': "+ unionIndex301)); + } + } + int unionIndex302 = (decoder.readIndex()); + if (unionIndex302 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(302, null); + } else { + if (unionIndex302 == 1) { + Utf8 charSequence302; + Object oldString302 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(302); + if (oldString302 instanceof Utf8) { + charSequence302 = (decoder).readString(((Utf8) oldString302)); + } else { + charSequence302 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(302, charSequence302); + } else { + throw new RuntimeException(("Illegal union index for 'F302': "+ unionIndex302)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema151(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex303 = (decoder.readIndex()); + if (unionIndex303 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(303, null); + } else { + if (unionIndex303 == 1) { + Utf8 charSequence303; + Object oldString303 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(303); + if (oldString303 instanceof Utf8) { + charSequence303 = (decoder).readString(((Utf8) oldString303)); + } else { + charSequence303 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(303, charSequence303); + } else { + throw new RuntimeException(("Illegal union index for 'F303': "+ unionIndex303)); + } + } + int unionIndex304 = (decoder.readIndex()); + if (unionIndex304 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(304, null); + } else { + if (unionIndex304 == 1) { + Utf8 charSequence304; + Object oldString304 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(304); + if (oldString304 instanceof Utf8) { + charSequence304 = (decoder).readString(((Utf8) oldString304)); + } else { + charSequence304 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(304, charSequence304); + } else { + throw new RuntimeException(("Illegal union index for 'F304': "+ unionIndex304)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema152(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex305 = (decoder.readIndex()); + if (unionIndex305 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(305, null); + } else { + if (unionIndex305 == 1) { + Utf8 charSequence305; + Object oldString305 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(305); + if (oldString305 instanceof Utf8) { + charSequence305 = (decoder).readString(((Utf8) oldString305)); + } else { + charSequence305 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(305, charSequence305); + } else { + throw new RuntimeException(("Illegal union index for 'F305': "+ unionIndex305)); + } + } + int unionIndex306 = (decoder.readIndex()); + if (unionIndex306 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(306, null); + } else { + if (unionIndex306 == 1) { + Utf8 charSequence306; + Object oldString306 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(306); + if (oldString306 instanceof Utf8) { + charSequence306 = (decoder).readString(((Utf8) oldString306)); + } else { + charSequence306 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(306, charSequence306); + } else { + throw new RuntimeException(("Illegal union index for 'F306': "+ unionIndex306)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema153(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex307 = (decoder.readIndex()); + if (unionIndex307 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(307, null); + } else { + if (unionIndex307 == 1) { + Utf8 charSequence307; + Object oldString307 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(307); + if (oldString307 instanceof Utf8) { + charSequence307 = (decoder).readString(((Utf8) oldString307)); + } else { + charSequence307 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(307, charSequence307); + } else { + throw new RuntimeException(("Illegal union index for 'F307': "+ unionIndex307)); + } + } + int unionIndex308 = (decoder.readIndex()); + if (unionIndex308 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(308, null); + } else { + if (unionIndex308 == 1) { + Utf8 charSequence308; + Object oldString308 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(308); + if (oldString308 instanceof Utf8) { + charSequence308 = (decoder).readString(((Utf8) oldString308)); + } else { + charSequence308 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(308, charSequence308); + } else { + throw new RuntimeException(("Illegal union index for 'F308': "+ unionIndex308)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema154(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex309 = (decoder.readIndex()); + if (unionIndex309 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(309, null); + } else { + if (unionIndex309 == 1) { + Utf8 charSequence309; + Object oldString309 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(309); + if (oldString309 instanceof Utf8) { + charSequence309 = (decoder).readString(((Utf8) oldString309)); + } else { + charSequence309 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(309, charSequence309); + } else { + throw new RuntimeException(("Illegal union index for 'F309': "+ unionIndex309)); + } + } + int unionIndex310 = (decoder.readIndex()); + if (unionIndex310 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(310, null); + } else { + if (unionIndex310 == 1) { + Utf8 charSequence310; + Object oldString310 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(310); + if (oldString310 instanceof Utf8) { + charSequence310 = (decoder).readString(((Utf8) oldString310)); + } else { + charSequence310 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(310, charSequence310); + } else { + throw new RuntimeException(("Illegal union index for 'F310': "+ unionIndex310)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema155(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex311 = (decoder.readIndex()); + if (unionIndex311 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(311, null); + } else { + if (unionIndex311 == 1) { + Utf8 charSequence311; + Object oldString311 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(311); + if (oldString311 instanceof Utf8) { + charSequence311 = (decoder).readString(((Utf8) oldString311)); + } else { + charSequence311 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(311, charSequence311); + } else { + throw new RuntimeException(("Illegal union index for 'F311': "+ unionIndex311)); + } + } + int unionIndex312 = (decoder.readIndex()); + if (unionIndex312 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(312, null); + } else { + if (unionIndex312 == 1) { + Utf8 charSequence312; + Object oldString312 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(312); + if (oldString312 instanceof Utf8) { + charSequence312 = (decoder).readString(((Utf8) oldString312)); + } else { + charSequence312 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(312, charSequence312); + } else { + throw new RuntimeException(("Illegal union index for 'F312': "+ unionIndex312)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema156(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex313 = (decoder.readIndex()); + if (unionIndex313 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(313, null); + } else { + if (unionIndex313 == 1) { + Utf8 charSequence313; + Object oldString313 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(313); + if (oldString313 instanceof Utf8) { + charSequence313 = (decoder).readString(((Utf8) oldString313)); + } else { + charSequence313 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(313, charSequence313); + } else { + throw new RuntimeException(("Illegal union index for 'F313': "+ unionIndex313)); + } + } + int unionIndex314 = (decoder.readIndex()); + if (unionIndex314 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(314, null); + } else { + if (unionIndex314 == 1) { + Utf8 charSequence314; + Object oldString314 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(314); + if (oldString314 instanceof Utf8) { + charSequence314 = (decoder).readString(((Utf8) oldString314)); + } else { + charSequence314 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(314, charSequence314); + } else { + throw new RuntimeException(("Illegal union index for 'F314': "+ unionIndex314)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema157(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex315 = (decoder.readIndex()); + if (unionIndex315 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(315, null); + } else { + if (unionIndex315 == 1) { + Utf8 charSequence315; + Object oldString315 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(315); + if (oldString315 instanceof Utf8) { + charSequence315 = (decoder).readString(((Utf8) oldString315)); + } else { + charSequence315 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(315, charSequence315); + } else { + throw new RuntimeException(("Illegal union index for 'F315': "+ unionIndex315)); + } + } + int unionIndex316 = (decoder.readIndex()); + if (unionIndex316 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(316, null); + } else { + if (unionIndex316 == 1) { + Utf8 charSequence316; + Object oldString316 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(316); + if (oldString316 instanceof Utf8) { + charSequence316 = (decoder).readString(((Utf8) oldString316)); + } else { + charSequence316 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(316, charSequence316); + } else { + throw new RuntimeException(("Illegal union index for 'F316': "+ unionIndex316)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema158(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex317 = (decoder.readIndex()); + if (unionIndex317 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(317, null); + } else { + if (unionIndex317 == 1) { + Utf8 charSequence317; + Object oldString317 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(317); + if (oldString317 instanceof Utf8) { + charSequence317 = (decoder).readString(((Utf8) oldString317)); + } else { + charSequence317 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(317, charSequence317); + } else { + throw new RuntimeException(("Illegal union index for 'F317': "+ unionIndex317)); + } + } + int unionIndex318 = (decoder.readIndex()); + if (unionIndex318 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(318, null); + } else { + if (unionIndex318 == 1) { + Utf8 charSequence318; + Object oldString318 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(318); + if (oldString318 instanceof Utf8) { + charSequence318 = (decoder).readString(((Utf8) oldString318)); + } else { + charSequence318 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(318, charSequence318); + } else { + throw new RuntimeException(("Illegal union index for 'F318': "+ unionIndex318)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema159(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex319 = (decoder.readIndex()); + if (unionIndex319 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(319, null); + } else { + if (unionIndex319 == 1) { + Utf8 charSequence319; + Object oldString319 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(319); + if (oldString319 instanceof Utf8) { + charSequence319 = (decoder).readString(((Utf8) oldString319)); + } else { + charSequence319 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(319, charSequence319); + } else { + throw new RuntimeException(("Illegal union index for 'F319': "+ unionIndex319)); + } + } + int unionIndex320 = (decoder.readIndex()); + if (unionIndex320 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(320, null); + } else { + if (unionIndex320 == 1) { + Utf8 charSequence320; + Object oldString320 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(320); + if (oldString320 instanceof Utf8) { + charSequence320 = (decoder).readString(((Utf8) oldString320)); + } else { + charSequence320 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(320, charSequence320); + } else { + throw new RuntimeException(("Illegal union index for 'F320': "+ unionIndex320)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema160(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex321 = (decoder.readIndex()); + if (unionIndex321 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(321, null); + } else { + if (unionIndex321 == 1) { + Utf8 charSequence321; + Object oldString321 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(321); + if (oldString321 instanceof Utf8) { + charSequence321 = (decoder).readString(((Utf8) oldString321)); + } else { + charSequence321 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(321, charSequence321); + } else { + throw new RuntimeException(("Illegal union index for 'F321': "+ unionIndex321)); + } + } + int unionIndex322 = (decoder.readIndex()); + if (unionIndex322 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(322, null); + } else { + if (unionIndex322 == 1) { + Utf8 charSequence322; + Object oldString322 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(322); + if (oldString322 instanceof Utf8) { + charSequence322 = (decoder).readString(((Utf8) oldString322)); + } else { + charSequence322 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(322, charSequence322); + } else { + throw new RuntimeException(("Illegal union index for 'F322': "+ unionIndex322)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema161(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex323 = (decoder.readIndex()); + if (unionIndex323 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(323, null); + } else { + if (unionIndex323 == 1) { + Utf8 charSequence323; + Object oldString323 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(323); + if (oldString323 instanceof Utf8) { + charSequence323 = (decoder).readString(((Utf8) oldString323)); + } else { + charSequence323 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(323, charSequence323); + } else { + throw new RuntimeException(("Illegal union index for 'F323': "+ unionIndex323)); + } + } + int unionIndex324 = (decoder.readIndex()); + if (unionIndex324 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(324, null); + } else { + if (unionIndex324 == 1) { + Utf8 charSequence324; + Object oldString324 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(324); + if (oldString324 instanceof Utf8) { + charSequence324 = (decoder).readString(((Utf8) oldString324)); + } else { + charSequence324 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(324, charSequence324); + } else { + throw new RuntimeException(("Illegal union index for 'F324': "+ unionIndex324)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema162(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex325 = (decoder.readIndex()); + if (unionIndex325 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(325, null); + } else { + if (unionIndex325 == 1) { + Utf8 charSequence325; + Object oldString325 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(325); + if (oldString325 instanceof Utf8) { + charSequence325 = (decoder).readString(((Utf8) oldString325)); + } else { + charSequence325 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(325, charSequence325); + } else { + throw new RuntimeException(("Illegal union index for 'F325': "+ unionIndex325)); + } + } + int unionIndex326 = (decoder.readIndex()); + if (unionIndex326 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(326, null); + } else { + if (unionIndex326 == 1) { + Utf8 charSequence326; + Object oldString326 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(326); + if (oldString326 instanceof Utf8) { + charSequence326 = (decoder).readString(((Utf8) oldString326)); + } else { + charSequence326 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(326, charSequence326); + } else { + throw new RuntimeException(("Illegal union index for 'F326': "+ unionIndex326)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema163(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex327 = (decoder.readIndex()); + if (unionIndex327 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(327, null); + } else { + if (unionIndex327 == 1) { + Utf8 charSequence327; + Object oldString327 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(327); + if (oldString327 instanceof Utf8) { + charSequence327 = (decoder).readString(((Utf8) oldString327)); + } else { + charSequence327 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(327, charSequence327); + } else { + throw new RuntimeException(("Illegal union index for 'F327': "+ unionIndex327)); + } + } + int unionIndex328 = (decoder.readIndex()); + if (unionIndex328 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(328, null); + } else { + if (unionIndex328 == 1) { + Utf8 charSequence328; + Object oldString328 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(328); + if (oldString328 instanceof Utf8) { + charSequence328 = (decoder).readString(((Utf8) oldString328)); + } else { + charSequence328 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(328, charSequence328); + } else { + throw new RuntimeException(("Illegal union index for 'F328': "+ unionIndex328)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema164(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex329 = (decoder.readIndex()); + if (unionIndex329 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(329, null); + } else { + if (unionIndex329 == 1) { + Utf8 charSequence329; + Object oldString329 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(329); + if (oldString329 instanceof Utf8) { + charSequence329 = (decoder).readString(((Utf8) oldString329)); + } else { + charSequence329 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(329, charSequence329); + } else { + throw new RuntimeException(("Illegal union index for 'F329': "+ unionIndex329)); + } + } + int unionIndex330 = (decoder.readIndex()); + if (unionIndex330 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(330, null); + } else { + if (unionIndex330 == 1) { + Utf8 charSequence330; + Object oldString330 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(330); + if (oldString330 instanceof Utf8) { + charSequence330 = (decoder).readString(((Utf8) oldString330)); + } else { + charSequence330 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(330, charSequence330); + } else { + throw new RuntimeException(("Illegal union index for 'F330': "+ unionIndex330)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema165(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex331 = (decoder.readIndex()); + if (unionIndex331 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(331, null); + } else { + if (unionIndex331 == 1) { + Utf8 charSequence331; + Object oldString331 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(331); + if (oldString331 instanceof Utf8) { + charSequence331 = (decoder).readString(((Utf8) oldString331)); + } else { + charSequence331 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(331, charSequence331); + } else { + throw new RuntimeException(("Illegal union index for 'F331': "+ unionIndex331)); + } + } + int unionIndex332 = (decoder.readIndex()); + if (unionIndex332 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(332, null); + } else { + if (unionIndex332 == 1) { + Utf8 charSequence332; + Object oldString332 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(332); + if (oldString332 instanceof Utf8) { + charSequence332 = (decoder).readString(((Utf8) oldString332)); + } else { + charSequence332 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(332, charSequence332); + } else { + throw new RuntimeException(("Illegal union index for 'F332': "+ unionIndex332)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema166(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex333 = (decoder.readIndex()); + if (unionIndex333 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(333, null); + } else { + if (unionIndex333 == 1) { + Utf8 charSequence333; + Object oldString333 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(333); + if (oldString333 instanceof Utf8) { + charSequence333 = (decoder).readString(((Utf8) oldString333)); + } else { + charSequence333 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(333, charSequence333); + } else { + throw new RuntimeException(("Illegal union index for 'F333': "+ unionIndex333)); + } + } + int unionIndex334 = (decoder.readIndex()); + if (unionIndex334 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(334, null); + } else { + if (unionIndex334 == 1) { + Utf8 charSequence334; + Object oldString334 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(334); + if (oldString334 instanceof Utf8) { + charSequence334 = (decoder).readString(((Utf8) oldString334)); + } else { + charSequence334 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(334, charSequence334); + } else { + throw new RuntimeException(("Illegal union index for 'F334': "+ unionIndex334)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema167(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex335 = (decoder.readIndex()); + if (unionIndex335 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(335, null); + } else { + if (unionIndex335 == 1) { + Utf8 charSequence335; + Object oldString335 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(335); + if (oldString335 instanceof Utf8) { + charSequence335 = (decoder).readString(((Utf8) oldString335)); + } else { + charSequence335 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(335, charSequence335); + } else { + throw new RuntimeException(("Illegal union index for 'F335': "+ unionIndex335)); + } + } + int unionIndex336 = (decoder.readIndex()); + if (unionIndex336 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(336, null); + } else { + if (unionIndex336 == 1) { + Utf8 charSequence336; + Object oldString336 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(336); + if (oldString336 instanceof Utf8) { + charSequence336 = (decoder).readString(((Utf8) oldString336)); + } else { + charSequence336 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(336, charSequence336); + } else { + throw new RuntimeException(("Illegal union index for 'F336': "+ unionIndex336)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema168(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex337 = (decoder.readIndex()); + if (unionIndex337 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(337, null); + } else { + if (unionIndex337 == 1) { + Utf8 charSequence337; + Object oldString337 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(337); + if (oldString337 instanceof Utf8) { + charSequence337 = (decoder).readString(((Utf8) oldString337)); + } else { + charSequence337 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(337, charSequence337); + } else { + throw new RuntimeException(("Illegal union index for 'F337': "+ unionIndex337)); + } + } + int unionIndex338 = (decoder.readIndex()); + if (unionIndex338 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(338, null); + } else { + if (unionIndex338 == 1) { + Utf8 charSequence338; + Object oldString338 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(338); + if (oldString338 instanceof Utf8) { + charSequence338 = (decoder).readString(((Utf8) oldString338)); + } else { + charSequence338 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(338, charSequence338); + } else { + throw new RuntimeException(("Illegal union index for 'F338': "+ unionIndex338)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema169(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex339 = (decoder.readIndex()); + if (unionIndex339 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(339, null); + } else { + if (unionIndex339 == 1) { + Utf8 charSequence339; + Object oldString339 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(339); + if (oldString339 instanceof Utf8) { + charSequence339 = (decoder).readString(((Utf8) oldString339)); + } else { + charSequence339 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(339, charSequence339); + } else { + throw new RuntimeException(("Illegal union index for 'F339': "+ unionIndex339)); + } + } + int unionIndex340 = (decoder.readIndex()); + if (unionIndex340 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(340, null); + } else { + if (unionIndex340 == 1) { + Utf8 charSequence340; + Object oldString340 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(340); + if (oldString340 instanceof Utf8) { + charSequence340 = (decoder).readString(((Utf8) oldString340)); + } else { + charSequence340 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(340, charSequence340); + } else { + throw new RuntimeException(("Illegal union index for 'F340': "+ unionIndex340)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema170(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex341 = (decoder.readIndex()); + if (unionIndex341 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(341, null); + } else { + if (unionIndex341 == 1) { + Utf8 charSequence341; + Object oldString341 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(341); + if (oldString341 instanceof Utf8) { + charSequence341 = (decoder).readString(((Utf8) oldString341)); + } else { + charSequence341 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(341, charSequence341); + } else { + throw new RuntimeException(("Illegal union index for 'F341': "+ unionIndex341)); + } + } + int unionIndex342 = (decoder.readIndex()); + if (unionIndex342 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(342, null); + } else { + if (unionIndex342 == 1) { + Utf8 charSequence342; + Object oldString342 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(342); + if (oldString342 instanceof Utf8) { + charSequence342 = (decoder).readString(((Utf8) oldString342)); + } else { + charSequence342 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(342, charSequence342); + } else { + throw new RuntimeException(("Illegal union index for 'F342': "+ unionIndex342)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema171(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex343 = (decoder.readIndex()); + if (unionIndex343 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(343, null); + } else { + if (unionIndex343 == 1) { + Utf8 charSequence343; + Object oldString343 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(343); + if (oldString343 instanceof Utf8) { + charSequence343 = (decoder).readString(((Utf8) oldString343)); + } else { + charSequence343 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(343, charSequence343); + } else { + throw new RuntimeException(("Illegal union index for 'F343': "+ unionIndex343)); + } + } + int unionIndex344 = (decoder.readIndex()); + if (unionIndex344 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(344, null); + } else { + if (unionIndex344 == 1) { + Utf8 charSequence344; + Object oldString344 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(344); + if (oldString344 instanceof Utf8) { + charSequence344 = (decoder).readString(((Utf8) oldString344)); + } else { + charSequence344 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(344, charSequence344); + } else { + throw new RuntimeException(("Illegal union index for 'F344': "+ unionIndex344)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema172(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex345 = (decoder.readIndex()); + if (unionIndex345 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(345, null); + } else { + if (unionIndex345 == 1) { + Utf8 charSequence345; + Object oldString345 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(345); + if (oldString345 instanceof Utf8) { + charSequence345 = (decoder).readString(((Utf8) oldString345)); + } else { + charSequence345 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(345, charSequence345); + } else { + throw new RuntimeException(("Illegal union index for 'F345': "+ unionIndex345)); + } + } + int unionIndex346 = (decoder.readIndex()); + if (unionIndex346 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(346, null); + } else { + if (unionIndex346 == 1) { + Utf8 charSequence346; + Object oldString346 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(346); + if (oldString346 instanceof Utf8) { + charSequence346 = (decoder).readString(((Utf8) oldString346)); + } else { + charSequence346 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(346, charSequence346); + } else { + throw new RuntimeException(("Illegal union index for 'F346': "+ unionIndex346)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema173(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex347 = (decoder.readIndex()); + if (unionIndex347 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(347, null); + } else { + if (unionIndex347 == 1) { + Utf8 charSequence347; + Object oldString347 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(347); + if (oldString347 instanceof Utf8) { + charSequence347 = (decoder).readString(((Utf8) oldString347)); + } else { + charSequence347 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(347, charSequence347); + } else { + throw new RuntimeException(("Illegal union index for 'F347': "+ unionIndex347)); + } + } + int unionIndex348 = (decoder.readIndex()); + if (unionIndex348 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(348, null); + } else { + if (unionIndex348 == 1) { + Utf8 charSequence348; + Object oldString348 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(348); + if (oldString348 instanceof Utf8) { + charSequence348 = (decoder).readString(((Utf8) oldString348)); + } else { + charSequence348 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(348, charSequence348); + } else { + throw new RuntimeException(("Illegal union index for 'F348': "+ unionIndex348)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema174(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex349 = (decoder.readIndex()); + if (unionIndex349 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(349, null); + } else { + if (unionIndex349 == 1) { + Utf8 charSequence349; + Object oldString349 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(349); + if (oldString349 instanceof Utf8) { + charSequence349 = (decoder).readString(((Utf8) oldString349)); + } else { + charSequence349 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(349, charSequence349); + } else { + throw new RuntimeException(("Illegal union index for 'F349': "+ unionIndex349)); + } + } + int unionIndex350 = (decoder.readIndex()); + if (unionIndex350 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(350, null); + } else { + if (unionIndex350 == 1) { + Utf8 charSequence350; + Object oldString350 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(350); + if (oldString350 instanceof Utf8) { + charSequence350 = (decoder).readString(((Utf8) oldString350)); + } else { + charSequence350 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(350, charSequence350); + } else { + throw new RuntimeException(("Illegal union index for 'F350': "+ unionIndex350)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema175(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex351 = (decoder.readIndex()); + if (unionIndex351 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(351, null); + } else { + if (unionIndex351 == 1) { + Utf8 charSequence351; + Object oldString351 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(351); + if (oldString351 instanceof Utf8) { + charSequence351 = (decoder).readString(((Utf8) oldString351)); + } else { + charSequence351 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(351, charSequence351); + } else { + throw new RuntimeException(("Illegal union index for 'F351': "+ unionIndex351)); + } + } + int unionIndex352 = (decoder.readIndex()); + if (unionIndex352 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(352, null); + } else { + if (unionIndex352 == 1) { + Utf8 charSequence352; + Object oldString352 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(352); + if (oldString352 instanceof Utf8) { + charSequence352 = (decoder).readString(((Utf8) oldString352)); + } else { + charSequence352 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(352, charSequence352); + } else { + throw new RuntimeException(("Illegal union index for 'F352': "+ unionIndex352)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema176(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex353 = (decoder.readIndex()); + if (unionIndex353 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(353, null); + } else { + if (unionIndex353 == 1) { + Utf8 charSequence353; + Object oldString353 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(353); + if (oldString353 instanceof Utf8) { + charSequence353 = (decoder).readString(((Utf8) oldString353)); + } else { + charSequence353 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(353, charSequence353); + } else { + throw new RuntimeException(("Illegal union index for 'F353': "+ unionIndex353)); + } + } + int unionIndex354 = (decoder.readIndex()); + if (unionIndex354 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(354, null); + } else { + if (unionIndex354 == 1) { + Utf8 charSequence354; + Object oldString354 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(354); + if (oldString354 instanceof Utf8) { + charSequence354 = (decoder).readString(((Utf8) oldString354)); + } else { + charSequence354 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(354, charSequence354); + } else { + throw new RuntimeException(("Illegal union index for 'F354': "+ unionIndex354)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema177(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex355 = (decoder.readIndex()); + if (unionIndex355 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(355, null); + } else { + if (unionIndex355 == 1) { + Utf8 charSequence355; + Object oldString355 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(355); + if (oldString355 instanceof Utf8) { + charSequence355 = (decoder).readString(((Utf8) oldString355)); + } else { + charSequence355 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(355, charSequence355); + } else { + throw new RuntimeException(("Illegal union index for 'F355': "+ unionIndex355)); + } + } + int unionIndex356 = (decoder.readIndex()); + if (unionIndex356 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(356, null); + } else { + if (unionIndex356 == 1) { + Utf8 charSequence356; + Object oldString356 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(356); + if (oldString356 instanceof Utf8) { + charSequence356 = (decoder).readString(((Utf8) oldString356)); + } else { + charSequence356 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(356, charSequence356); + } else { + throw new RuntimeException(("Illegal union index for 'F356': "+ unionIndex356)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema178(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex357 = (decoder.readIndex()); + if (unionIndex357 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(357, null); + } else { + if (unionIndex357 == 1) { + Utf8 charSequence357; + Object oldString357 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(357); + if (oldString357 instanceof Utf8) { + charSequence357 = (decoder).readString(((Utf8) oldString357)); + } else { + charSequence357 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(357, charSequence357); + } else { + throw new RuntimeException(("Illegal union index for 'F357': "+ unionIndex357)); + } + } + int unionIndex358 = (decoder.readIndex()); + if (unionIndex358 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(358, null); + } else { + if (unionIndex358 == 1) { + Utf8 charSequence358; + Object oldString358 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(358); + if (oldString358 instanceof Utf8) { + charSequence358 = (decoder).readString(((Utf8) oldString358)); + } else { + charSequence358 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(358, charSequence358); + } else { + throw new RuntimeException(("Illegal union index for 'F358': "+ unionIndex358)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema179(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex359 = (decoder.readIndex()); + if (unionIndex359 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(359, null); + } else { + if (unionIndex359 == 1) { + Utf8 charSequence359; + Object oldString359 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(359); + if (oldString359 instanceof Utf8) { + charSequence359 = (decoder).readString(((Utf8) oldString359)); + } else { + charSequence359 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(359, charSequence359); + } else { + throw new RuntimeException(("Illegal union index for 'F359': "+ unionIndex359)); + } + } + int unionIndex360 = (decoder.readIndex()); + if (unionIndex360 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(360, null); + } else { + if (unionIndex360 == 1) { + Utf8 charSequence360; + Object oldString360 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(360); + if (oldString360 instanceof Utf8) { + charSequence360 = (decoder).readString(((Utf8) oldString360)); + } else { + charSequence360 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(360, charSequence360); + } else { + throw new RuntimeException(("Illegal union index for 'F360': "+ unionIndex360)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema180(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex361 = (decoder.readIndex()); + if (unionIndex361 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(361, null); + } else { + if (unionIndex361 == 1) { + Utf8 charSequence361; + Object oldString361 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(361); + if (oldString361 instanceof Utf8) { + charSequence361 = (decoder).readString(((Utf8) oldString361)); + } else { + charSequence361 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(361, charSequence361); + } else { + throw new RuntimeException(("Illegal union index for 'F361': "+ unionIndex361)); + } + } + int unionIndex362 = (decoder.readIndex()); + if (unionIndex362 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(362, null); + } else { + if (unionIndex362 == 1) { + Utf8 charSequence362; + Object oldString362 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(362); + if (oldString362 instanceof Utf8) { + charSequence362 = (decoder).readString(((Utf8) oldString362)); + } else { + charSequence362 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(362, charSequence362); + } else { + throw new RuntimeException(("Illegal union index for 'F362': "+ unionIndex362)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema181(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex363 = (decoder.readIndex()); + if (unionIndex363 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(363, null); + } else { + if (unionIndex363 == 1) { + Utf8 charSequence363; + Object oldString363 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(363); + if (oldString363 instanceof Utf8) { + charSequence363 = (decoder).readString(((Utf8) oldString363)); + } else { + charSequence363 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(363, charSequence363); + } else { + throw new RuntimeException(("Illegal union index for 'F363': "+ unionIndex363)); + } + } + int unionIndex364 = (decoder.readIndex()); + if (unionIndex364 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(364, null); + } else { + if (unionIndex364 == 1) { + Utf8 charSequence364; + Object oldString364 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(364); + if (oldString364 instanceof Utf8) { + charSequence364 = (decoder).readString(((Utf8) oldString364)); + } else { + charSequence364 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(364, charSequence364); + } else { + throw new RuntimeException(("Illegal union index for 'F364': "+ unionIndex364)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema182(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex365 = (decoder.readIndex()); + if (unionIndex365 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(365, null); + } else { + if (unionIndex365 == 1) { + Utf8 charSequence365; + Object oldString365 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(365); + if (oldString365 instanceof Utf8) { + charSequence365 = (decoder).readString(((Utf8) oldString365)); + } else { + charSequence365 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(365, charSequence365); + } else { + throw new RuntimeException(("Illegal union index for 'F365': "+ unionIndex365)); + } + } + int unionIndex366 = (decoder.readIndex()); + if (unionIndex366 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(366, null); + } else { + if (unionIndex366 == 1) { + Utf8 charSequence366; + Object oldString366 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(366); + if (oldString366 instanceof Utf8) { + charSequence366 = (decoder).readString(((Utf8) oldString366)); + } else { + charSequence366 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(366, charSequence366); + } else { + throw new RuntimeException(("Illegal union index for 'F366': "+ unionIndex366)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema183(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex367 = (decoder.readIndex()); + if (unionIndex367 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(367, null); + } else { + if (unionIndex367 == 1) { + Utf8 charSequence367; + Object oldString367 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(367); + if (oldString367 instanceof Utf8) { + charSequence367 = (decoder).readString(((Utf8) oldString367)); + } else { + charSequence367 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(367, charSequence367); + } else { + throw new RuntimeException(("Illegal union index for 'F367': "+ unionIndex367)); + } + } + int unionIndex368 = (decoder.readIndex()); + if (unionIndex368 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(368, null); + } else { + if (unionIndex368 == 1) { + Utf8 charSequence368; + Object oldString368 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(368); + if (oldString368 instanceof Utf8) { + charSequence368 = (decoder).readString(((Utf8) oldString368)); + } else { + charSequence368 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(368, charSequence368); + } else { + throw new RuntimeException(("Illegal union index for 'F368': "+ unionIndex368)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema184(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex369 = (decoder.readIndex()); + if (unionIndex369 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(369, null); + } else { + if (unionIndex369 == 1) { + Utf8 charSequence369; + Object oldString369 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(369); + if (oldString369 instanceof Utf8) { + charSequence369 = (decoder).readString(((Utf8) oldString369)); + } else { + charSequence369 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(369, charSequence369); + } else { + throw new RuntimeException(("Illegal union index for 'F369': "+ unionIndex369)); + } + } + int unionIndex370 = (decoder.readIndex()); + if (unionIndex370 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(370, null); + } else { + if (unionIndex370 == 1) { + Utf8 charSequence370; + Object oldString370 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(370); + if (oldString370 instanceof Utf8) { + charSequence370 = (decoder).readString(((Utf8) oldString370)); + } else { + charSequence370 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(370, charSequence370); + } else { + throw new RuntimeException(("Illegal union index for 'F370': "+ unionIndex370)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema185(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex371 = (decoder.readIndex()); + if (unionIndex371 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(371, null); + } else { + if (unionIndex371 == 1) { + Utf8 charSequence371; + Object oldString371 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(371); + if (oldString371 instanceof Utf8) { + charSequence371 = (decoder).readString(((Utf8) oldString371)); + } else { + charSequence371 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(371, charSequence371); + } else { + throw new RuntimeException(("Illegal union index for 'F371': "+ unionIndex371)); + } + } + int unionIndex372 = (decoder.readIndex()); + if (unionIndex372 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(372, null); + } else { + if (unionIndex372 == 1) { + Utf8 charSequence372; + Object oldString372 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(372); + if (oldString372 instanceof Utf8) { + charSequence372 = (decoder).readString(((Utf8) oldString372)); + } else { + charSequence372 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(372, charSequence372); + } else { + throw new RuntimeException(("Illegal union index for 'F372': "+ unionIndex372)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema186(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex373 = (decoder.readIndex()); + if (unionIndex373 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(373, null); + } else { + if (unionIndex373 == 1) { + Utf8 charSequence373; + Object oldString373 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(373); + if (oldString373 instanceof Utf8) { + charSequence373 = (decoder).readString(((Utf8) oldString373)); + } else { + charSequence373 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(373, charSequence373); + } else { + throw new RuntimeException(("Illegal union index for 'F373': "+ unionIndex373)); + } + } + int unionIndex374 = (decoder.readIndex()); + if (unionIndex374 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(374, null); + } else { + if (unionIndex374 == 1) { + Utf8 charSequence374; + Object oldString374 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(374); + if (oldString374 instanceof Utf8) { + charSequence374 = (decoder).readString(((Utf8) oldString374)); + } else { + charSequence374 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(374, charSequence374); + } else { + throw new RuntimeException(("Illegal union index for 'F374': "+ unionIndex374)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema187(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex375 = (decoder.readIndex()); + if (unionIndex375 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(375, null); + } else { + if (unionIndex375 == 1) { + Utf8 charSequence375; + Object oldString375 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(375); + if (oldString375 instanceof Utf8) { + charSequence375 = (decoder).readString(((Utf8) oldString375)); + } else { + charSequence375 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(375, charSequence375); + } else { + throw new RuntimeException(("Illegal union index for 'F375': "+ unionIndex375)); + } + } + int unionIndex376 = (decoder.readIndex()); + if (unionIndex376 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(376, null); + } else { + if (unionIndex376 == 1) { + Utf8 charSequence376; + Object oldString376 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(376); + if (oldString376 instanceof Utf8) { + charSequence376 = (decoder).readString(((Utf8) oldString376)); + } else { + charSequence376 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(376, charSequence376); + } else { + throw new RuntimeException(("Illegal union index for 'F376': "+ unionIndex376)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema188(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex377 = (decoder.readIndex()); + if (unionIndex377 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(377, null); + } else { + if (unionIndex377 == 1) { + Utf8 charSequence377; + Object oldString377 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(377); + if (oldString377 instanceof Utf8) { + charSequence377 = (decoder).readString(((Utf8) oldString377)); + } else { + charSequence377 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(377, charSequence377); + } else { + throw new RuntimeException(("Illegal union index for 'F377': "+ unionIndex377)); + } + } + int unionIndex378 = (decoder.readIndex()); + if (unionIndex378 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(378, null); + } else { + if (unionIndex378 == 1) { + Utf8 charSequence378; + Object oldString378 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(378); + if (oldString378 instanceof Utf8) { + charSequence378 = (decoder).readString(((Utf8) oldString378)); + } else { + charSequence378 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(378, charSequence378); + } else { + throw new RuntimeException(("Illegal union index for 'F378': "+ unionIndex378)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema189(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex379 = (decoder.readIndex()); + if (unionIndex379 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(379, null); + } else { + if (unionIndex379 == 1) { + Utf8 charSequence379; + Object oldString379 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(379); + if (oldString379 instanceof Utf8) { + charSequence379 = (decoder).readString(((Utf8) oldString379)); + } else { + charSequence379 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(379, charSequence379); + } else { + throw new RuntimeException(("Illegal union index for 'F379': "+ unionIndex379)); + } + } + int unionIndex380 = (decoder.readIndex()); + if (unionIndex380 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(380, null); + } else { + if (unionIndex380 == 1) { + Utf8 charSequence380; + Object oldString380 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(380); + if (oldString380 instanceof Utf8) { + charSequence380 = (decoder).readString(((Utf8) oldString380)); + } else { + charSequence380 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(380, charSequence380); + } else { + throw new RuntimeException(("Illegal union index for 'F380': "+ unionIndex380)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema190(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex381 = (decoder.readIndex()); + if (unionIndex381 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(381, null); + } else { + if (unionIndex381 == 1) { + Utf8 charSequence381; + Object oldString381 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(381); + if (oldString381 instanceof Utf8) { + charSequence381 = (decoder).readString(((Utf8) oldString381)); + } else { + charSequence381 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(381, charSequence381); + } else { + throw new RuntimeException(("Illegal union index for 'F381': "+ unionIndex381)); + } + } + int unionIndex382 = (decoder.readIndex()); + if (unionIndex382 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(382, null); + } else { + if (unionIndex382 == 1) { + Utf8 charSequence382; + Object oldString382 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(382); + if (oldString382 instanceof Utf8) { + charSequence382 = (decoder).readString(((Utf8) oldString382)); + } else { + charSequence382 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(382, charSequence382); + } else { + throw new RuntimeException(("Illegal union index for 'F382': "+ unionIndex382)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema191(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex383 = (decoder.readIndex()); + if (unionIndex383 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(383, null); + } else { + if (unionIndex383 == 1) { + Utf8 charSequence383; + Object oldString383 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(383); + if (oldString383 instanceof Utf8) { + charSequence383 = (decoder).readString(((Utf8) oldString383)); + } else { + charSequence383 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(383, charSequence383); + } else { + throw new RuntimeException(("Illegal union index for 'F383': "+ unionIndex383)); + } + } + int unionIndex384 = (decoder.readIndex()); + if (unionIndex384 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(384, null); + } else { + if (unionIndex384 == 1) { + Utf8 charSequence384; + Object oldString384 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(384); + if (oldString384 instanceof Utf8) { + charSequence384 = (decoder).readString(((Utf8) oldString384)); + } else { + charSequence384 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(384, charSequence384); + } else { + throw new RuntimeException(("Illegal union index for 'F384': "+ unionIndex384)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema192(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex385 = (decoder.readIndex()); + if (unionIndex385 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(385, null); + } else { + if (unionIndex385 == 1) { + Utf8 charSequence385; + Object oldString385 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(385); + if (oldString385 instanceof Utf8) { + charSequence385 = (decoder).readString(((Utf8) oldString385)); + } else { + charSequence385 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(385, charSequence385); + } else { + throw new RuntimeException(("Illegal union index for 'F385': "+ unionIndex385)); + } + } + int unionIndex386 = (decoder.readIndex()); + if (unionIndex386 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(386, null); + } else { + if (unionIndex386 == 1) { + Utf8 charSequence386; + Object oldString386 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(386); + if (oldString386 instanceof Utf8) { + charSequence386 = (decoder).readString(((Utf8) oldString386)); + } else { + charSequence386 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(386, charSequence386); + } else { + throw new RuntimeException(("Illegal union index for 'F386': "+ unionIndex386)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema193(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex387 = (decoder.readIndex()); + if (unionIndex387 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(387, null); + } else { + if (unionIndex387 == 1) { + Utf8 charSequence387; + Object oldString387 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(387); + if (oldString387 instanceof Utf8) { + charSequence387 = (decoder).readString(((Utf8) oldString387)); + } else { + charSequence387 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(387, charSequence387); + } else { + throw new RuntimeException(("Illegal union index for 'F387': "+ unionIndex387)); + } + } + int unionIndex388 = (decoder.readIndex()); + if (unionIndex388 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(388, null); + } else { + if (unionIndex388 == 1) { + Utf8 charSequence388; + Object oldString388 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(388); + if (oldString388 instanceof Utf8) { + charSequence388 = (decoder).readString(((Utf8) oldString388)); + } else { + charSequence388 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(388, charSequence388); + } else { + throw new RuntimeException(("Illegal union index for 'F388': "+ unionIndex388)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema194(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex389 = (decoder.readIndex()); + if (unionIndex389 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(389, null); + } else { + if (unionIndex389 == 1) { + Utf8 charSequence389; + Object oldString389 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(389); + if (oldString389 instanceof Utf8) { + charSequence389 = (decoder).readString(((Utf8) oldString389)); + } else { + charSequence389 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(389, charSequence389); + } else { + throw new RuntimeException(("Illegal union index for 'F389': "+ unionIndex389)); + } + } + int unionIndex390 = (decoder.readIndex()); + if (unionIndex390 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(390, null); + } else { + if (unionIndex390 == 1) { + Utf8 charSequence390; + Object oldString390 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(390); + if (oldString390 instanceof Utf8) { + charSequence390 = (decoder).readString(((Utf8) oldString390)); + } else { + charSequence390 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(390, charSequence390); + } else { + throw new RuntimeException(("Illegal union index for 'F390': "+ unionIndex390)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema195(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex391 = (decoder.readIndex()); + if (unionIndex391 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(391, null); + } else { + if (unionIndex391 == 1) { + Utf8 charSequence391; + Object oldString391 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(391); + if (oldString391 instanceof Utf8) { + charSequence391 = (decoder).readString(((Utf8) oldString391)); + } else { + charSequence391 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(391, charSequence391); + } else { + throw new RuntimeException(("Illegal union index for 'F391': "+ unionIndex391)); + } + } + int unionIndex392 = (decoder.readIndex()); + if (unionIndex392 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(392, null); + } else { + if (unionIndex392 == 1) { + Utf8 charSequence392; + Object oldString392 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(392); + if (oldString392 instanceof Utf8) { + charSequence392 = (decoder).readString(((Utf8) oldString392)); + } else { + charSequence392 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(392, charSequence392); + } else { + throw new RuntimeException(("Illegal union index for 'F392': "+ unionIndex392)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema196(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex393 = (decoder.readIndex()); + if (unionIndex393 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(393, null); + } else { + if (unionIndex393 == 1) { + Utf8 charSequence393; + Object oldString393 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(393); + if (oldString393 instanceof Utf8) { + charSequence393 = (decoder).readString(((Utf8) oldString393)); + } else { + charSequence393 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(393, charSequence393); + } else { + throw new RuntimeException(("Illegal union index for 'F393': "+ unionIndex393)); + } + } + int unionIndex394 = (decoder.readIndex()); + if (unionIndex394 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(394, null); + } else { + if (unionIndex394 == 1) { + Utf8 charSequence394; + Object oldString394 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(394); + if (oldString394 instanceof Utf8) { + charSequence394 = (decoder).readString(((Utf8) oldString394)); + } else { + charSequence394 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(394, charSequence394); + } else { + throw new RuntimeException(("Illegal union index for 'F394': "+ unionIndex394)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema197(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex395 = (decoder.readIndex()); + if (unionIndex395 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(395, null); + } else { + if (unionIndex395 == 1) { + Utf8 charSequence395; + Object oldString395 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(395); + if (oldString395 instanceof Utf8) { + charSequence395 = (decoder).readString(((Utf8) oldString395)); + } else { + charSequence395 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(395, charSequence395); + } else { + throw new RuntimeException(("Illegal union index for 'F395': "+ unionIndex395)); + } + } + int unionIndex396 = (decoder.readIndex()); + if (unionIndex396 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(396, null); + } else { + if (unionIndex396 == 1) { + Utf8 charSequence396; + Object oldString396 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(396); + if (oldString396 instanceof Utf8) { + charSequence396 = (decoder).readString(((Utf8) oldString396)); + } else { + charSequence396 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(396, charSequence396); + } else { + throw new RuntimeException(("Illegal union index for 'F396': "+ unionIndex396)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema198(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex397 = (decoder.readIndex()); + if (unionIndex397 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(397, null); + } else { + if (unionIndex397 == 1) { + Utf8 charSequence397; + Object oldString397 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(397); + if (oldString397 instanceof Utf8) { + charSequence397 = (decoder).readString(((Utf8) oldString397)); + } else { + charSequence397 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(397, charSequence397); + } else { + throw new RuntimeException(("Illegal union index for 'F397': "+ unionIndex397)); + } + } + int unionIndex398 = (decoder.readIndex()); + if (unionIndex398 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(398, null); + } else { + if (unionIndex398 == 1) { + Utf8 charSequence398; + Object oldString398 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(398); + if (oldString398 instanceof Utf8) { + charSequence398 = (decoder).readString(((Utf8) oldString398)); + } else { + charSequence398 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(398, charSequence398); + } else { + throw new RuntimeException(("Illegal union index for 'F398': "+ unionIndex398)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema199(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex399 = (decoder.readIndex()); + if (unionIndex399 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(399, null); + } else { + if (unionIndex399 == 1) { + Utf8 charSequence399; + Object oldString399 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(399); + if (oldString399 instanceof Utf8) { + charSequence399 = (decoder).readString(((Utf8) oldString399)); + } else { + charSequence399 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(399, charSequence399); + } else { + throw new RuntimeException(("Illegal union index for 'F399': "+ unionIndex399)); + } + } + int unionIndex400 = (decoder.readIndex()); + if (unionIndex400 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(400, null); + } else { + if (unionIndex400 == 1) { + Utf8 charSequence400; + Object oldString400 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(400); + if (oldString400 instanceof Utf8) { + charSequence400 = (decoder).readString(((Utf8) oldString400)); + } else { + charSequence400 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(400, charSequence400); + } else { + throw new RuntimeException(("Illegal union index for 'F400': "+ unionIndex400)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema200(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex401 = (decoder.readIndex()); + if (unionIndex401 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(401, null); + } else { + if (unionIndex401 == 1) { + Utf8 charSequence401; + Object oldString401 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(401); + if (oldString401 instanceof Utf8) { + charSequence401 = (decoder).readString(((Utf8) oldString401)); + } else { + charSequence401 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(401, charSequence401); + } else { + throw new RuntimeException(("Illegal union index for 'F401': "+ unionIndex401)); + } + } + int unionIndex402 = (decoder.readIndex()); + if (unionIndex402 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(402, null); + } else { + if (unionIndex402 == 1) { + Utf8 charSequence402; + Object oldString402 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(402); + if (oldString402 instanceof Utf8) { + charSequence402 = (decoder).readString(((Utf8) oldString402)); + } else { + charSequence402 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(402, charSequence402); + } else { + throw new RuntimeException(("Illegal union index for 'F402': "+ unionIndex402)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema201(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex403 = (decoder.readIndex()); + if (unionIndex403 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(403, null); + } else { + if (unionIndex403 == 1) { + Utf8 charSequence403; + Object oldString403 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(403); + if (oldString403 instanceof Utf8) { + charSequence403 = (decoder).readString(((Utf8) oldString403)); + } else { + charSequence403 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(403, charSequence403); + } else { + throw new RuntimeException(("Illegal union index for 'F403': "+ unionIndex403)); + } + } + int unionIndex404 = (decoder.readIndex()); + if (unionIndex404 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(404, null); + } else { + if (unionIndex404 == 1) { + Utf8 charSequence404; + Object oldString404 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(404); + if (oldString404 instanceof Utf8) { + charSequence404 = (decoder).readString(((Utf8) oldString404)); + } else { + charSequence404 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(404, charSequence404); + } else { + throw new RuntimeException(("Illegal union index for 'F404': "+ unionIndex404)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema202(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex405 = (decoder.readIndex()); + if (unionIndex405 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(405, null); + } else { + if (unionIndex405 == 1) { + Utf8 charSequence405; + Object oldString405 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(405); + if (oldString405 instanceof Utf8) { + charSequence405 = (decoder).readString(((Utf8) oldString405)); + } else { + charSequence405 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(405, charSequence405); + } else { + throw new RuntimeException(("Illegal union index for 'F405': "+ unionIndex405)); + } + } + int unionIndex406 = (decoder.readIndex()); + if (unionIndex406 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(406, null); + } else { + if (unionIndex406 == 1) { + Utf8 charSequence406; + Object oldString406 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(406); + if (oldString406 instanceof Utf8) { + charSequence406 = (decoder).readString(((Utf8) oldString406)); + } else { + charSequence406 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(406, charSequence406); + } else { + throw new RuntimeException(("Illegal union index for 'F406': "+ unionIndex406)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema203(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex407 = (decoder.readIndex()); + if (unionIndex407 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(407, null); + } else { + if (unionIndex407 == 1) { + Utf8 charSequence407; + Object oldString407 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(407); + if (oldString407 instanceof Utf8) { + charSequence407 = (decoder).readString(((Utf8) oldString407)); + } else { + charSequence407 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(407, charSequence407); + } else { + throw new RuntimeException(("Illegal union index for 'F407': "+ unionIndex407)); + } + } + int unionIndex408 = (decoder.readIndex()); + if (unionIndex408 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(408, null); + } else { + if (unionIndex408 == 1) { + Utf8 charSequence408; + Object oldString408 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(408); + if (oldString408 instanceof Utf8) { + charSequence408 = (decoder).readString(((Utf8) oldString408)); + } else { + charSequence408 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(408, charSequence408); + } else { + throw new RuntimeException(("Illegal union index for 'F408': "+ unionIndex408)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema204(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex409 = (decoder.readIndex()); + if (unionIndex409 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(409, null); + } else { + if (unionIndex409 == 1) { + Utf8 charSequence409; + Object oldString409 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(409); + if (oldString409 instanceof Utf8) { + charSequence409 = (decoder).readString(((Utf8) oldString409)); + } else { + charSequence409 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(409, charSequence409); + } else { + throw new RuntimeException(("Illegal union index for 'F409': "+ unionIndex409)); + } + } + int unionIndex410 = (decoder.readIndex()); + if (unionIndex410 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(410, null); + } else { + if (unionIndex410 == 1) { + Utf8 charSequence410; + Object oldString410 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(410); + if (oldString410 instanceof Utf8) { + charSequence410 = (decoder).readString(((Utf8) oldString410)); + } else { + charSequence410 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(410, charSequence410); + } else { + throw new RuntimeException(("Illegal union index for 'F410': "+ unionIndex410)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema205(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex411 = (decoder.readIndex()); + if (unionIndex411 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(411, null); + } else { + if (unionIndex411 == 1) { + Utf8 charSequence411; + Object oldString411 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(411); + if (oldString411 instanceof Utf8) { + charSequence411 = (decoder).readString(((Utf8) oldString411)); + } else { + charSequence411 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(411, charSequence411); + } else { + throw new RuntimeException(("Illegal union index for 'F411': "+ unionIndex411)); + } + } + int unionIndex412 = (decoder.readIndex()); + if (unionIndex412 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(412, null); + } else { + if (unionIndex412 == 1) { + Utf8 charSequence412; + Object oldString412 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(412); + if (oldString412 instanceof Utf8) { + charSequence412 = (decoder).readString(((Utf8) oldString412)); + } else { + charSequence412 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(412, charSequence412); + } else { + throw new RuntimeException(("Illegal union index for 'F412': "+ unionIndex412)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema206(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex413 = (decoder.readIndex()); + if (unionIndex413 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(413, null); + } else { + if (unionIndex413 == 1) { + Utf8 charSequence413; + Object oldString413 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(413); + if (oldString413 instanceof Utf8) { + charSequence413 = (decoder).readString(((Utf8) oldString413)); + } else { + charSequence413 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(413, charSequence413); + } else { + throw new RuntimeException(("Illegal union index for 'F413': "+ unionIndex413)); + } + } + int unionIndex414 = (decoder.readIndex()); + if (unionIndex414 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(414, null); + } else { + if (unionIndex414 == 1) { + Utf8 charSequence414; + Object oldString414 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(414); + if (oldString414 instanceof Utf8) { + charSequence414 = (decoder).readString(((Utf8) oldString414)); + } else { + charSequence414 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(414, charSequence414); + } else { + throw new RuntimeException(("Illegal union index for 'F414': "+ unionIndex414)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema207(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex415 = (decoder.readIndex()); + if (unionIndex415 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(415, null); + } else { + if (unionIndex415 == 1) { + Utf8 charSequence415; + Object oldString415 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(415); + if (oldString415 instanceof Utf8) { + charSequence415 = (decoder).readString(((Utf8) oldString415)); + } else { + charSequence415 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(415, charSequence415); + } else { + throw new RuntimeException(("Illegal union index for 'F415': "+ unionIndex415)); + } + } + int unionIndex416 = (decoder.readIndex()); + if (unionIndex416 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(416, null); + } else { + if (unionIndex416 == 1) { + Utf8 charSequence416; + Object oldString416 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(416); + if (oldString416 instanceof Utf8) { + charSequence416 = (decoder).readString(((Utf8) oldString416)); + } else { + charSequence416 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(416, charSequence416); + } else { + throw new RuntimeException(("Illegal union index for 'F416': "+ unionIndex416)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema208(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex417 = (decoder.readIndex()); + if (unionIndex417 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(417, null); + } else { + if (unionIndex417 == 1) { + Utf8 charSequence417; + Object oldString417 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(417); + if (oldString417 instanceof Utf8) { + charSequence417 = (decoder).readString(((Utf8) oldString417)); + } else { + charSequence417 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(417, charSequence417); + } else { + throw new RuntimeException(("Illegal union index for 'F417': "+ unionIndex417)); + } + } + int unionIndex418 = (decoder.readIndex()); + if (unionIndex418 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(418, null); + } else { + if (unionIndex418 == 1) { + Utf8 charSequence418; + Object oldString418 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(418); + if (oldString418 instanceof Utf8) { + charSequence418 = (decoder).readString(((Utf8) oldString418)); + } else { + charSequence418 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(418, charSequence418); + } else { + throw new RuntimeException(("Illegal union index for 'F418': "+ unionIndex418)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema209(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex419 = (decoder.readIndex()); + if (unionIndex419 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(419, null); + } else { + if (unionIndex419 == 1) { + Utf8 charSequence419; + Object oldString419 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(419); + if (oldString419 instanceof Utf8) { + charSequence419 = (decoder).readString(((Utf8) oldString419)); + } else { + charSequence419 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(419, charSequence419); + } else { + throw new RuntimeException(("Illegal union index for 'F419': "+ unionIndex419)); + } + } + int unionIndex420 = (decoder.readIndex()); + if (unionIndex420 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(420, null); + } else { + if (unionIndex420 == 1) { + Utf8 charSequence420; + Object oldString420 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(420); + if (oldString420 instanceof Utf8) { + charSequence420 = (decoder).readString(((Utf8) oldString420)); + } else { + charSequence420 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(420, charSequence420); + } else { + throw new RuntimeException(("Illegal union index for 'F420': "+ unionIndex420)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema210(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex421 = (decoder.readIndex()); + if (unionIndex421 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(421, null); + } else { + if (unionIndex421 == 1) { + Utf8 charSequence421; + Object oldString421 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(421); + if (oldString421 instanceof Utf8) { + charSequence421 = (decoder).readString(((Utf8) oldString421)); + } else { + charSequence421 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(421, charSequence421); + } else { + throw new RuntimeException(("Illegal union index for 'F421': "+ unionIndex421)); + } + } + int unionIndex422 = (decoder.readIndex()); + if (unionIndex422 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(422, null); + } else { + if (unionIndex422 == 1) { + Utf8 charSequence422; + Object oldString422 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(422); + if (oldString422 instanceof Utf8) { + charSequence422 = (decoder).readString(((Utf8) oldString422)); + } else { + charSequence422 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(422, charSequence422); + } else { + throw new RuntimeException(("Illegal union index for 'F422': "+ unionIndex422)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema211(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex423 = (decoder.readIndex()); + if (unionIndex423 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(423, null); + } else { + if (unionIndex423 == 1) { + Utf8 charSequence423; + Object oldString423 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(423); + if (oldString423 instanceof Utf8) { + charSequence423 = (decoder).readString(((Utf8) oldString423)); + } else { + charSequence423 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(423, charSequence423); + } else { + throw new RuntimeException(("Illegal union index for 'F423': "+ unionIndex423)); + } + } + int unionIndex424 = (decoder.readIndex()); + if (unionIndex424 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(424, null); + } else { + if (unionIndex424 == 1) { + Utf8 charSequence424; + Object oldString424 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(424); + if (oldString424 instanceof Utf8) { + charSequence424 = (decoder).readString(((Utf8) oldString424)); + } else { + charSequence424 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(424, charSequence424); + } else { + throw new RuntimeException(("Illegal union index for 'F424': "+ unionIndex424)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema212(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex425 = (decoder.readIndex()); + if (unionIndex425 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(425, null); + } else { + if (unionIndex425 == 1) { + Utf8 charSequence425; + Object oldString425 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(425); + if (oldString425 instanceof Utf8) { + charSequence425 = (decoder).readString(((Utf8) oldString425)); + } else { + charSequence425 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(425, charSequence425); + } else { + throw new RuntimeException(("Illegal union index for 'F425': "+ unionIndex425)); + } + } + int unionIndex426 = (decoder.readIndex()); + if (unionIndex426 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(426, null); + } else { + if (unionIndex426 == 1) { + Utf8 charSequence426; + Object oldString426 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(426); + if (oldString426 instanceof Utf8) { + charSequence426 = (decoder).readString(((Utf8) oldString426)); + } else { + charSequence426 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(426, charSequence426); + } else { + throw new RuntimeException(("Illegal union index for 'F426': "+ unionIndex426)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema213(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex427 = (decoder.readIndex()); + if (unionIndex427 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(427, null); + } else { + if (unionIndex427 == 1) { + Utf8 charSequence427; + Object oldString427 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(427); + if (oldString427 instanceof Utf8) { + charSequence427 = (decoder).readString(((Utf8) oldString427)); + } else { + charSequence427 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(427, charSequence427); + } else { + throw new RuntimeException(("Illegal union index for 'F427': "+ unionIndex427)); + } + } + int unionIndex428 = (decoder.readIndex()); + if (unionIndex428 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(428, null); + } else { + if (unionIndex428 == 1) { + Utf8 charSequence428; + Object oldString428 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(428); + if (oldString428 instanceof Utf8) { + charSequence428 = (decoder).readString(((Utf8) oldString428)); + } else { + charSequence428 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(428, charSequence428); + } else { + throw new RuntimeException(("Illegal union index for 'F428': "+ unionIndex428)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema214(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex429 = (decoder.readIndex()); + if (unionIndex429 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(429, null); + } else { + if (unionIndex429 == 1) { + Utf8 charSequence429; + Object oldString429 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(429); + if (oldString429 instanceof Utf8) { + charSequence429 = (decoder).readString(((Utf8) oldString429)); + } else { + charSequence429 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(429, charSequence429); + } else { + throw new RuntimeException(("Illegal union index for 'F429': "+ unionIndex429)); + } + } + int unionIndex430 = (decoder.readIndex()); + if (unionIndex430 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(430, null); + } else { + if (unionIndex430 == 1) { + Utf8 charSequence430; + Object oldString430 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(430); + if (oldString430 instanceof Utf8) { + charSequence430 = (decoder).readString(((Utf8) oldString430)); + } else { + charSequence430 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(430, charSequence430); + } else { + throw new RuntimeException(("Illegal union index for 'F430': "+ unionIndex430)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema215(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex431 = (decoder.readIndex()); + if (unionIndex431 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(431, null); + } else { + if (unionIndex431 == 1) { + Utf8 charSequence431; + Object oldString431 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(431); + if (oldString431 instanceof Utf8) { + charSequence431 = (decoder).readString(((Utf8) oldString431)); + } else { + charSequence431 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(431, charSequence431); + } else { + throw new RuntimeException(("Illegal union index for 'F431': "+ unionIndex431)); + } + } + int unionIndex432 = (decoder.readIndex()); + if (unionIndex432 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(432, null); + } else { + if (unionIndex432 == 1) { + Utf8 charSequence432; + Object oldString432 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(432); + if (oldString432 instanceof Utf8) { + charSequence432 = (decoder).readString(((Utf8) oldString432)); + } else { + charSequence432 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(432, charSequence432); + } else { + throw new RuntimeException(("Illegal union index for 'F432': "+ unionIndex432)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema216(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex433 = (decoder.readIndex()); + if (unionIndex433 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(433, null); + } else { + if (unionIndex433 == 1) { + Utf8 charSequence433; + Object oldString433 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(433); + if (oldString433 instanceof Utf8) { + charSequence433 = (decoder).readString(((Utf8) oldString433)); + } else { + charSequence433 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(433, charSequence433); + } else { + throw new RuntimeException(("Illegal union index for 'F433': "+ unionIndex433)); + } + } + int unionIndex434 = (decoder.readIndex()); + if (unionIndex434 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(434, null); + } else { + if (unionIndex434 == 1) { + Utf8 charSequence434; + Object oldString434 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(434); + if (oldString434 instanceof Utf8) { + charSequence434 = (decoder).readString(((Utf8) oldString434)); + } else { + charSequence434 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(434, charSequence434); + } else { + throw new RuntimeException(("Illegal union index for 'F434': "+ unionIndex434)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema217(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex435 = (decoder.readIndex()); + if (unionIndex435 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(435, null); + } else { + if (unionIndex435 == 1) { + Utf8 charSequence435; + Object oldString435 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(435); + if (oldString435 instanceof Utf8) { + charSequence435 = (decoder).readString(((Utf8) oldString435)); + } else { + charSequence435 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(435, charSequence435); + } else { + throw new RuntimeException(("Illegal union index for 'F435': "+ unionIndex435)); + } + } + int unionIndex436 = (decoder.readIndex()); + if (unionIndex436 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(436, null); + } else { + if (unionIndex436 == 1) { + Utf8 charSequence436; + Object oldString436 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(436); + if (oldString436 instanceof Utf8) { + charSequence436 = (decoder).readString(((Utf8) oldString436)); + } else { + charSequence436 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(436, charSequence436); + } else { + throw new RuntimeException(("Illegal union index for 'F436': "+ unionIndex436)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema218(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex437 = (decoder.readIndex()); + if (unionIndex437 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(437, null); + } else { + if (unionIndex437 == 1) { + Utf8 charSequence437; + Object oldString437 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(437); + if (oldString437 instanceof Utf8) { + charSequence437 = (decoder).readString(((Utf8) oldString437)); + } else { + charSequence437 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(437, charSequence437); + } else { + throw new RuntimeException(("Illegal union index for 'F437': "+ unionIndex437)); + } + } + int unionIndex438 = (decoder.readIndex()); + if (unionIndex438 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(438, null); + } else { + if (unionIndex438 == 1) { + Utf8 charSequence438; + Object oldString438 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(438); + if (oldString438 instanceof Utf8) { + charSequence438 = (decoder).readString(((Utf8) oldString438)); + } else { + charSequence438 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(438, charSequence438); + } else { + throw new RuntimeException(("Illegal union index for 'F438': "+ unionIndex438)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema219(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex439 = (decoder.readIndex()); + if (unionIndex439 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(439, null); + } else { + if (unionIndex439 == 1) { + Utf8 charSequence439; + Object oldString439 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(439); + if (oldString439 instanceof Utf8) { + charSequence439 = (decoder).readString(((Utf8) oldString439)); + } else { + charSequence439 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(439, charSequence439); + } else { + throw new RuntimeException(("Illegal union index for 'F439': "+ unionIndex439)); + } + } + int unionIndex440 = (decoder.readIndex()); + if (unionIndex440 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(440, null); + } else { + if (unionIndex440 == 1) { + Utf8 charSequence440; + Object oldString440 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(440); + if (oldString440 instanceof Utf8) { + charSequence440 = (decoder).readString(((Utf8) oldString440)); + } else { + charSequence440 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(440, charSequence440); + } else { + throw new RuntimeException(("Illegal union index for 'F440': "+ unionIndex440)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema220(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex441 = (decoder.readIndex()); + if (unionIndex441 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(441, null); + } else { + if (unionIndex441 == 1) { + Utf8 charSequence441; + Object oldString441 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(441); + if (oldString441 instanceof Utf8) { + charSequence441 = (decoder).readString(((Utf8) oldString441)); + } else { + charSequence441 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(441, charSequence441); + } else { + throw new RuntimeException(("Illegal union index for 'F441': "+ unionIndex441)); + } + } + int unionIndex442 = (decoder.readIndex()); + if (unionIndex442 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(442, null); + } else { + if (unionIndex442 == 1) { + Utf8 charSequence442; + Object oldString442 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(442); + if (oldString442 instanceof Utf8) { + charSequence442 = (decoder).readString(((Utf8) oldString442)); + } else { + charSequence442 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(442, charSequence442); + } else { + throw new RuntimeException(("Illegal union index for 'F442': "+ unionIndex442)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema221(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex443 = (decoder.readIndex()); + if (unionIndex443 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(443, null); + } else { + if (unionIndex443 == 1) { + Utf8 charSequence443; + Object oldString443 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(443); + if (oldString443 instanceof Utf8) { + charSequence443 = (decoder).readString(((Utf8) oldString443)); + } else { + charSequence443 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(443, charSequence443); + } else { + throw new RuntimeException(("Illegal union index for 'F443': "+ unionIndex443)); + } + } + int unionIndex444 = (decoder.readIndex()); + if (unionIndex444 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(444, null); + } else { + if (unionIndex444 == 1) { + Utf8 charSequence444; + Object oldString444 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(444); + if (oldString444 instanceof Utf8) { + charSequence444 = (decoder).readString(((Utf8) oldString444)); + } else { + charSequence444 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(444, charSequence444); + } else { + throw new RuntimeException(("Illegal union index for 'F444': "+ unionIndex444)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema222(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex445 = (decoder.readIndex()); + if (unionIndex445 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(445, null); + } else { + if (unionIndex445 == 1) { + Utf8 charSequence445; + Object oldString445 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(445); + if (oldString445 instanceof Utf8) { + charSequence445 = (decoder).readString(((Utf8) oldString445)); + } else { + charSequence445 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(445, charSequence445); + } else { + throw new RuntimeException(("Illegal union index for 'F445': "+ unionIndex445)); + } + } + int unionIndex446 = (decoder.readIndex()); + if (unionIndex446 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(446, null); + } else { + if (unionIndex446 == 1) { + Utf8 charSequence446; + Object oldString446 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(446); + if (oldString446 instanceof Utf8) { + charSequence446 = (decoder).readString(((Utf8) oldString446)); + } else { + charSequence446 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(446, charSequence446); + } else { + throw new RuntimeException(("Illegal union index for 'F446': "+ unionIndex446)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema223(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex447 = (decoder.readIndex()); + if (unionIndex447 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(447, null); + } else { + if (unionIndex447 == 1) { + Utf8 charSequence447; + Object oldString447 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(447); + if (oldString447 instanceof Utf8) { + charSequence447 = (decoder).readString(((Utf8) oldString447)); + } else { + charSequence447 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(447, charSequence447); + } else { + throw new RuntimeException(("Illegal union index for 'F447': "+ unionIndex447)); + } + } + int unionIndex448 = (decoder.readIndex()); + if (unionIndex448 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(448, null); + } else { + if (unionIndex448 == 1) { + Utf8 charSequence448; + Object oldString448 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(448); + if (oldString448 instanceof Utf8) { + charSequence448 = (decoder).readString(((Utf8) oldString448)); + } else { + charSequence448 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(448, charSequence448); + } else { + throw new RuntimeException(("Illegal union index for 'F448': "+ unionIndex448)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema224(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex449 = (decoder.readIndex()); + if (unionIndex449 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(449, null); + } else { + if (unionIndex449 == 1) { + Utf8 charSequence449; + Object oldString449 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(449); + if (oldString449 instanceof Utf8) { + charSequence449 = (decoder).readString(((Utf8) oldString449)); + } else { + charSequence449 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(449, charSequence449); + } else { + throw new RuntimeException(("Illegal union index for 'F449': "+ unionIndex449)); + } + } + int unionIndex450 = (decoder.readIndex()); + if (unionIndex450 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(450, null); + } else { + if (unionIndex450 == 1) { + Utf8 charSequence450; + Object oldString450 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(450); + if (oldString450 instanceof Utf8) { + charSequence450 = (decoder).readString(((Utf8) oldString450)); + } else { + charSequence450 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(450, charSequence450); + } else { + throw new RuntimeException(("Illegal union index for 'F450': "+ unionIndex450)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema225(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex451 = (decoder.readIndex()); + if (unionIndex451 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(451, null); + } else { + if (unionIndex451 == 1) { + Utf8 charSequence451; + Object oldString451 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(451); + if (oldString451 instanceof Utf8) { + charSequence451 = (decoder).readString(((Utf8) oldString451)); + } else { + charSequence451 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(451, charSequence451); + } else { + throw new RuntimeException(("Illegal union index for 'F451': "+ unionIndex451)); + } + } + int unionIndex452 = (decoder.readIndex()); + if (unionIndex452 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(452, null); + } else { + if (unionIndex452 == 1) { + Utf8 charSequence452; + Object oldString452 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(452); + if (oldString452 instanceof Utf8) { + charSequence452 = (decoder).readString(((Utf8) oldString452)); + } else { + charSequence452 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(452, charSequence452); + } else { + throw new RuntimeException(("Illegal union index for 'F452': "+ unionIndex452)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema226(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex453 = (decoder.readIndex()); + if (unionIndex453 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(453, null); + } else { + if (unionIndex453 == 1) { + Utf8 charSequence453; + Object oldString453 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(453); + if (oldString453 instanceof Utf8) { + charSequence453 = (decoder).readString(((Utf8) oldString453)); + } else { + charSequence453 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(453, charSequence453); + } else { + throw new RuntimeException(("Illegal union index for 'F453': "+ unionIndex453)); + } + } + int unionIndex454 = (decoder.readIndex()); + if (unionIndex454 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(454, null); + } else { + if (unionIndex454 == 1) { + Utf8 charSequence454; + Object oldString454 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(454); + if (oldString454 instanceof Utf8) { + charSequence454 = (decoder).readString(((Utf8) oldString454)); + } else { + charSequence454 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(454, charSequence454); + } else { + throw new RuntimeException(("Illegal union index for 'F454': "+ unionIndex454)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema227(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex455 = (decoder.readIndex()); + if (unionIndex455 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(455, null); + } else { + if (unionIndex455 == 1) { + Utf8 charSequence455; + Object oldString455 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(455); + if (oldString455 instanceof Utf8) { + charSequence455 = (decoder).readString(((Utf8) oldString455)); + } else { + charSequence455 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(455, charSequence455); + } else { + throw new RuntimeException(("Illegal union index for 'F455': "+ unionIndex455)); + } + } + int unionIndex456 = (decoder.readIndex()); + if (unionIndex456 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(456, null); + } else { + if (unionIndex456 == 1) { + Utf8 charSequence456; + Object oldString456 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(456); + if (oldString456 instanceof Utf8) { + charSequence456 = (decoder).readString(((Utf8) oldString456)); + } else { + charSequence456 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(456, charSequence456); + } else { + throw new RuntimeException(("Illegal union index for 'F456': "+ unionIndex456)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema228(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex457 = (decoder.readIndex()); + if (unionIndex457 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(457, null); + } else { + if (unionIndex457 == 1) { + Utf8 charSequence457; + Object oldString457 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(457); + if (oldString457 instanceof Utf8) { + charSequence457 = (decoder).readString(((Utf8) oldString457)); + } else { + charSequence457 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(457, charSequence457); + } else { + throw new RuntimeException(("Illegal union index for 'F457': "+ unionIndex457)); + } + } + int unionIndex458 = (decoder.readIndex()); + if (unionIndex458 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(458, null); + } else { + if (unionIndex458 == 1) { + Utf8 charSequence458; + Object oldString458 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(458); + if (oldString458 instanceof Utf8) { + charSequence458 = (decoder).readString(((Utf8) oldString458)); + } else { + charSequence458 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(458, charSequence458); + } else { + throw new RuntimeException(("Illegal union index for 'F458': "+ unionIndex458)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema229(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex459 = (decoder.readIndex()); + if (unionIndex459 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(459, null); + } else { + if (unionIndex459 == 1) { + Utf8 charSequence459; + Object oldString459 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(459); + if (oldString459 instanceof Utf8) { + charSequence459 = (decoder).readString(((Utf8) oldString459)); + } else { + charSequence459 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(459, charSequence459); + } else { + throw new RuntimeException(("Illegal union index for 'F459': "+ unionIndex459)); + } + } + int unionIndex460 = (decoder.readIndex()); + if (unionIndex460 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(460, null); + } else { + if (unionIndex460 == 1) { + Utf8 charSequence460; + Object oldString460 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(460); + if (oldString460 instanceof Utf8) { + charSequence460 = (decoder).readString(((Utf8) oldString460)); + } else { + charSequence460 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(460, charSequence460); + } else { + throw new RuntimeException(("Illegal union index for 'F460': "+ unionIndex460)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema230(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex461 = (decoder.readIndex()); + if (unionIndex461 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(461, null); + } else { + if (unionIndex461 == 1) { + Utf8 charSequence461; + Object oldString461 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(461); + if (oldString461 instanceof Utf8) { + charSequence461 = (decoder).readString(((Utf8) oldString461)); + } else { + charSequence461 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(461, charSequence461); + } else { + throw new RuntimeException(("Illegal union index for 'F461': "+ unionIndex461)); + } + } + int unionIndex462 = (decoder.readIndex()); + if (unionIndex462 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(462, null); + } else { + if (unionIndex462 == 1) { + Utf8 charSequence462; + Object oldString462 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(462); + if (oldString462 instanceof Utf8) { + charSequence462 = (decoder).readString(((Utf8) oldString462)); + } else { + charSequence462 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(462, charSequence462); + } else { + throw new RuntimeException(("Illegal union index for 'F462': "+ unionIndex462)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema231(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex463 = (decoder.readIndex()); + if (unionIndex463 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(463, null); + } else { + if (unionIndex463 == 1) { + Utf8 charSequence463; + Object oldString463 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(463); + if (oldString463 instanceof Utf8) { + charSequence463 = (decoder).readString(((Utf8) oldString463)); + } else { + charSequence463 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(463, charSequence463); + } else { + throw new RuntimeException(("Illegal union index for 'F463': "+ unionIndex463)); + } + } + int unionIndex464 = (decoder.readIndex()); + if (unionIndex464 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(464, null); + } else { + if (unionIndex464 == 1) { + Utf8 charSequence464; + Object oldString464 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(464); + if (oldString464 instanceof Utf8) { + charSequence464 = (decoder).readString(((Utf8) oldString464)); + } else { + charSequence464 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(464, charSequence464); + } else { + throw new RuntimeException(("Illegal union index for 'F464': "+ unionIndex464)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema232(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex465 = (decoder.readIndex()); + if (unionIndex465 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(465, null); + } else { + if (unionIndex465 == 1) { + Utf8 charSequence465; + Object oldString465 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(465); + if (oldString465 instanceof Utf8) { + charSequence465 = (decoder).readString(((Utf8) oldString465)); + } else { + charSequence465 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(465, charSequence465); + } else { + throw new RuntimeException(("Illegal union index for 'F465': "+ unionIndex465)); + } + } + int unionIndex466 = (decoder.readIndex()); + if (unionIndex466 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(466, null); + } else { + if (unionIndex466 == 1) { + Utf8 charSequence466; + Object oldString466 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(466); + if (oldString466 instanceof Utf8) { + charSequence466 = (decoder).readString(((Utf8) oldString466)); + } else { + charSequence466 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(466, charSequence466); + } else { + throw new RuntimeException(("Illegal union index for 'F466': "+ unionIndex466)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema233(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex467 = (decoder.readIndex()); + if (unionIndex467 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(467, null); + } else { + if (unionIndex467 == 1) { + Utf8 charSequence467; + Object oldString467 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(467); + if (oldString467 instanceof Utf8) { + charSequence467 = (decoder).readString(((Utf8) oldString467)); + } else { + charSequence467 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(467, charSequence467); + } else { + throw new RuntimeException(("Illegal union index for 'F467': "+ unionIndex467)); + } + } + int unionIndex468 = (decoder.readIndex()); + if (unionIndex468 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(468, null); + } else { + if (unionIndex468 == 1) { + Utf8 charSequence468; + Object oldString468 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(468); + if (oldString468 instanceof Utf8) { + charSequence468 = (decoder).readString(((Utf8) oldString468)); + } else { + charSequence468 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(468, charSequence468); + } else { + throw new RuntimeException(("Illegal union index for 'F468': "+ unionIndex468)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema234(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex469 = (decoder.readIndex()); + if (unionIndex469 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(469, null); + } else { + if (unionIndex469 == 1) { + Utf8 charSequence469; + Object oldString469 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(469); + if (oldString469 instanceof Utf8) { + charSequence469 = (decoder).readString(((Utf8) oldString469)); + } else { + charSequence469 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(469, charSequence469); + } else { + throw new RuntimeException(("Illegal union index for 'F469': "+ unionIndex469)); + } + } + int unionIndex470 = (decoder.readIndex()); + if (unionIndex470 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(470, null); + } else { + if (unionIndex470 == 1) { + Utf8 charSequence470; + Object oldString470 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(470); + if (oldString470 instanceof Utf8) { + charSequence470 = (decoder).readString(((Utf8) oldString470)); + } else { + charSequence470 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(470, charSequence470); + } else { + throw new RuntimeException(("Illegal union index for 'F470': "+ unionIndex470)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema235(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex471 = (decoder.readIndex()); + if (unionIndex471 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(471, null); + } else { + if (unionIndex471 == 1) { + Utf8 charSequence471; + Object oldString471 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(471); + if (oldString471 instanceof Utf8) { + charSequence471 = (decoder).readString(((Utf8) oldString471)); + } else { + charSequence471 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(471, charSequence471); + } else { + throw new RuntimeException(("Illegal union index for 'F471': "+ unionIndex471)); + } + } + int unionIndex472 = (decoder.readIndex()); + if (unionIndex472 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(472, null); + } else { + if (unionIndex472 == 1) { + Utf8 charSequence472; + Object oldString472 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(472); + if (oldString472 instanceof Utf8) { + charSequence472 = (decoder).readString(((Utf8) oldString472)); + } else { + charSequence472 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(472, charSequence472); + } else { + throw new RuntimeException(("Illegal union index for 'F472': "+ unionIndex472)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema236(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex473 = (decoder.readIndex()); + if (unionIndex473 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(473, null); + } else { + if (unionIndex473 == 1) { + Utf8 charSequence473; + Object oldString473 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(473); + if (oldString473 instanceof Utf8) { + charSequence473 = (decoder).readString(((Utf8) oldString473)); + } else { + charSequence473 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(473, charSequence473); + } else { + throw new RuntimeException(("Illegal union index for 'F473': "+ unionIndex473)); + } + } + int unionIndex474 = (decoder.readIndex()); + if (unionIndex474 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(474, null); + } else { + if (unionIndex474 == 1) { + Utf8 charSequence474; + Object oldString474 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(474); + if (oldString474 instanceof Utf8) { + charSequence474 = (decoder).readString(((Utf8) oldString474)); + } else { + charSequence474 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(474, charSequence474); + } else { + throw new RuntimeException(("Illegal union index for 'F474': "+ unionIndex474)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema237(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex475 = (decoder.readIndex()); + if (unionIndex475 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(475, null); + } else { + if (unionIndex475 == 1) { + Utf8 charSequence475; + Object oldString475 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(475); + if (oldString475 instanceof Utf8) { + charSequence475 = (decoder).readString(((Utf8) oldString475)); + } else { + charSequence475 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(475, charSequence475); + } else { + throw new RuntimeException(("Illegal union index for 'F475': "+ unionIndex475)); + } + } + int unionIndex476 = (decoder.readIndex()); + if (unionIndex476 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(476, null); + } else { + if (unionIndex476 == 1) { + Utf8 charSequence476; + Object oldString476 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(476); + if (oldString476 instanceof Utf8) { + charSequence476 = (decoder).readString(((Utf8) oldString476)); + } else { + charSequence476 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(476, charSequence476); + } else { + throw new RuntimeException(("Illegal union index for 'F476': "+ unionIndex476)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema238(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex477 = (decoder.readIndex()); + if (unionIndex477 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(477, null); + } else { + if (unionIndex477 == 1) { + Utf8 charSequence477; + Object oldString477 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(477); + if (oldString477 instanceof Utf8) { + charSequence477 = (decoder).readString(((Utf8) oldString477)); + } else { + charSequence477 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(477, charSequence477); + } else { + throw new RuntimeException(("Illegal union index for 'F477': "+ unionIndex477)); + } + } + int unionIndex478 = (decoder.readIndex()); + if (unionIndex478 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(478, null); + } else { + if (unionIndex478 == 1) { + Utf8 charSequence478; + Object oldString478 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(478); + if (oldString478 instanceof Utf8) { + charSequence478 = (decoder).readString(((Utf8) oldString478)); + } else { + charSequence478 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(478, charSequence478); + } else { + throw new RuntimeException(("Illegal union index for 'F478': "+ unionIndex478)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema239(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex479 = (decoder.readIndex()); + if (unionIndex479 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(479, null); + } else { + if (unionIndex479 == 1) { + Utf8 charSequence479; + Object oldString479 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(479); + if (oldString479 instanceof Utf8) { + charSequence479 = (decoder).readString(((Utf8) oldString479)); + } else { + charSequence479 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(479, charSequence479); + } else { + throw new RuntimeException(("Illegal union index for 'F479': "+ unionIndex479)); + } + } + int unionIndex480 = (decoder.readIndex()); + if (unionIndex480 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(480, null); + } else { + if (unionIndex480 == 1) { + Utf8 charSequence480; + Object oldString480 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(480); + if (oldString480 instanceof Utf8) { + charSequence480 = (decoder).readString(((Utf8) oldString480)); + } else { + charSequence480 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(480, charSequence480); + } else { + throw new RuntimeException(("Illegal union index for 'F480': "+ unionIndex480)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema240(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex481 = (decoder.readIndex()); + if (unionIndex481 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(481, null); + } else { + if (unionIndex481 == 1) { + Utf8 charSequence481; + Object oldString481 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(481); + if (oldString481 instanceof Utf8) { + charSequence481 = (decoder).readString(((Utf8) oldString481)); + } else { + charSequence481 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(481, charSequence481); + } else { + throw new RuntimeException(("Illegal union index for 'F481': "+ unionIndex481)); + } + } + int unionIndex482 = (decoder.readIndex()); + if (unionIndex482 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(482, null); + } else { + if (unionIndex482 == 1) { + Utf8 charSequence482; + Object oldString482 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(482); + if (oldString482 instanceof Utf8) { + charSequence482 = (decoder).readString(((Utf8) oldString482)); + } else { + charSequence482 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(482, charSequence482); + } else { + throw new RuntimeException(("Illegal union index for 'F482': "+ unionIndex482)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema241(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex483 = (decoder.readIndex()); + if (unionIndex483 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(483, null); + } else { + if (unionIndex483 == 1) { + Utf8 charSequence483; + Object oldString483 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(483); + if (oldString483 instanceof Utf8) { + charSequence483 = (decoder).readString(((Utf8) oldString483)); + } else { + charSequence483 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(483, charSequence483); + } else { + throw new RuntimeException(("Illegal union index for 'F483': "+ unionIndex483)); + } + } + int unionIndex484 = (decoder.readIndex()); + if (unionIndex484 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(484, null); + } else { + if (unionIndex484 == 1) { + Utf8 charSequence484; + Object oldString484 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(484); + if (oldString484 instanceof Utf8) { + charSequence484 = (decoder).readString(((Utf8) oldString484)); + } else { + charSequence484 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(484, charSequence484); + } else { + throw new RuntimeException(("Illegal union index for 'F484': "+ unionIndex484)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema242(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex485 = (decoder.readIndex()); + if (unionIndex485 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(485, null); + } else { + if (unionIndex485 == 1) { + Utf8 charSequence485; + Object oldString485 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(485); + if (oldString485 instanceof Utf8) { + charSequence485 = (decoder).readString(((Utf8) oldString485)); + } else { + charSequence485 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(485, charSequence485); + } else { + throw new RuntimeException(("Illegal union index for 'F485': "+ unionIndex485)); + } + } + int unionIndex486 = (decoder.readIndex()); + if (unionIndex486 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(486, null); + } else { + if (unionIndex486 == 1) { + Utf8 charSequence486; + Object oldString486 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(486); + if (oldString486 instanceof Utf8) { + charSequence486 = (decoder).readString(((Utf8) oldString486)); + } else { + charSequence486 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(486, charSequence486); + } else { + throw new RuntimeException(("Illegal union index for 'F486': "+ unionIndex486)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema243(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex487 = (decoder.readIndex()); + if (unionIndex487 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(487, null); + } else { + if (unionIndex487 == 1) { + Utf8 charSequence487; + Object oldString487 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(487); + if (oldString487 instanceof Utf8) { + charSequence487 = (decoder).readString(((Utf8) oldString487)); + } else { + charSequence487 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(487, charSequence487); + } else { + throw new RuntimeException(("Illegal union index for 'F487': "+ unionIndex487)); + } + } + int unionIndex488 = (decoder.readIndex()); + if (unionIndex488 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(488, null); + } else { + if (unionIndex488 == 1) { + Utf8 charSequence488; + Object oldString488 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(488); + if (oldString488 instanceof Utf8) { + charSequence488 = (decoder).readString(((Utf8) oldString488)); + } else { + charSequence488 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(488, charSequence488); + } else { + throw new RuntimeException(("Illegal union index for 'F488': "+ unionIndex488)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema244(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex489 = (decoder.readIndex()); + if (unionIndex489 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(489, null); + } else { + if (unionIndex489 == 1) { + Utf8 charSequence489; + Object oldString489 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(489); + if (oldString489 instanceof Utf8) { + charSequence489 = (decoder).readString(((Utf8) oldString489)); + } else { + charSequence489 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(489, charSequence489); + } else { + throw new RuntimeException(("Illegal union index for 'F489': "+ unionIndex489)); + } + } + int unionIndex490 = (decoder.readIndex()); + if (unionIndex490 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(490, null); + } else { + if (unionIndex490 == 1) { + Utf8 charSequence490; + Object oldString490 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(490); + if (oldString490 instanceof Utf8) { + charSequence490 = (decoder).readString(((Utf8) oldString490)); + } else { + charSequence490 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(490, charSequence490); + } else { + throw new RuntimeException(("Illegal union index for 'F490': "+ unionIndex490)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema245(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex491 = (decoder.readIndex()); + if (unionIndex491 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(491, null); + } else { + if (unionIndex491 == 1) { + Utf8 charSequence491; + Object oldString491 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(491); + if (oldString491 instanceof Utf8) { + charSequence491 = (decoder).readString(((Utf8) oldString491)); + } else { + charSequence491 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(491, charSequence491); + } else { + throw new RuntimeException(("Illegal union index for 'F491': "+ unionIndex491)); + } + } + int unionIndex492 = (decoder.readIndex()); + if (unionIndex492 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(492, null); + } else { + if (unionIndex492 == 1) { + Utf8 charSequence492; + Object oldString492 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(492); + if (oldString492 instanceof Utf8) { + charSequence492 = (decoder).readString(((Utf8) oldString492)); + } else { + charSequence492 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(492, charSequence492); + } else { + throw new RuntimeException(("Illegal union index for 'F492': "+ unionIndex492)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema246(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex493 = (decoder.readIndex()); + if (unionIndex493 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(493, null); + } else { + if (unionIndex493 == 1) { + Utf8 charSequence493; + Object oldString493 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(493); + if (oldString493 instanceof Utf8) { + charSequence493 = (decoder).readString(((Utf8) oldString493)); + } else { + charSequence493 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(493, charSequence493); + } else { + throw new RuntimeException(("Illegal union index for 'F493': "+ unionIndex493)); + } + } + int unionIndex494 = (decoder.readIndex()); + if (unionIndex494 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(494, null); + } else { + if (unionIndex494 == 1) { + Utf8 charSequence494; + Object oldString494 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(494); + if (oldString494 instanceof Utf8) { + charSequence494 = (decoder).readString(((Utf8) oldString494)); + } else { + charSequence494 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(494, charSequence494); + } else { + throw new RuntimeException(("Illegal union index for 'F494': "+ unionIndex494)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema247(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex495 = (decoder.readIndex()); + if (unionIndex495 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(495, null); + } else { + if (unionIndex495 == 1) { + Utf8 charSequence495; + Object oldString495 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(495); + if (oldString495 instanceof Utf8) { + charSequence495 = (decoder).readString(((Utf8) oldString495)); + } else { + charSequence495 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(495, charSequence495); + } else { + throw new RuntimeException(("Illegal union index for 'F495': "+ unionIndex495)); + } + } + int unionIndex496 = (decoder.readIndex()); + if (unionIndex496 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(496, null); + } else { + if (unionIndex496 == 1) { + Utf8 charSequence496; + Object oldString496 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(496); + if (oldString496 instanceof Utf8) { + charSequence496 = (decoder).readString(((Utf8) oldString496)); + } else { + charSequence496 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(496, charSequence496); + } else { + throw new RuntimeException(("Illegal union index for 'F496': "+ unionIndex496)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema248(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex497 = (decoder.readIndex()); + if (unionIndex497 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(497, null); + } else { + if (unionIndex497 == 1) { + Utf8 charSequence497; + Object oldString497 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(497); + if (oldString497 instanceof Utf8) { + charSequence497 = (decoder).readString(((Utf8) oldString497)); + } else { + charSequence497 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(497, charSequence497); + } else { + throw new RuntimeException(("Illegal union index for 'F497': "+ unionIndex497)); + } + } + int unionIndex498 = (decoder.readIndex()); + if (unionIndex498 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(498, null); + } else { + if (unionIndex498 == 1) { + Utf8 charSequence498; + Object oldString498 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(498); + if (oldString498 instanceof Utf8) { + charSequence498 = (decoder).readString(((Utf8) oldString498)); + } else { + charSequence498 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(498, charSequence498); + } else { + throw new RuntimeException(("Illegal union index for 'F498': "+ unionIndex498)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema249(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex499 = (decoder.readIndex()); + if (unionIndex499 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(499, null); + } else { + if (unionIndex499 == 1) { + Utf8 charSequence499; + Object oldString499 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(499); + if (oldString499 instanceof Utf8) { + charSequence499 = (decoder).readString(((Utf8) oldString499)); + } else { + charSequence499 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(499, charSequence499); + } else { + throw new RuntimeException(("Illegal union index for 'F499': "+ unionIndex499)); + } + } + int unionIndex500 = (decoder.readIndex()); + if (unionIndex500 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(500, null); + } else { + if (unionIndex500 == 1) { + Utf8 charSequence500; + Object oldString500 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(500); + if (oldString500 instanceof Utf8) { + charSequence500 = (decoder).readString(((Utf8) oldString500)); + } else { + charSequence500 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(500, charSequence500); + } else { + throw new RuntimeException(("Illegal union index for 'F500': "+ unionIndex500)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema250(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex501 = (decoder.readIndex()); + if (unionIndex501 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(501, null); + } else { + if (unionIndex501 == 1) { + Utf8 charSequence501; + Object oldString501 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(501); + if (oldString501 instanceof Utf8) { + charSequence501 = (decoder).readString(((Utf8) oldString501)); + } else { + charSequence501 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(501, charSequence501); + } else { + throw new RuntimeException(("Illegal union index for 'F501': "+ unionIndex501)); + } + } + int unionIndex502 = (decoder.readIndex()); + if (unionIndex502 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(502, null); + } else { + if (unionIndex502 == 1) { + Utf8 charSequence502; + Object oldString502 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(502); + if (oldString502 instanceof Utf8) { + charSequence502 = (decoder).readString(((Utf8) oldString502)); + } else { + charSequence502 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(502, charSequence502); + } else { + throw new RuntimeException(("Illegal union index for 'F502': "+ unionIndex502)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema251(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex503 = (decoder.readIndex()); + if (unionIndex503 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(503, null); + } else { + if (unionIndex503 == 1) { + Utf8 charSequence503; + Object oldString503 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(503); + if (oldString503 instanceof Utf8) { + charSequence503 = (decoder).readString(((Utf8) oldString503)); + } else { + charSequence503 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(503, charSequence503); + } else { + throw new RuntimeException(("Illegal union index for 'F503': "+ unionIndex503)); + } + } + int unionIndex504 = (decoder.readIndex()); + if (unionIndex504 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(504, null); + } else { + if (unionIndex504 == 1) { + Utf8 charSequence504; + Object oldString504 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(504); + if (oldString504 instanceof Utf8) { + charSequence504 = (decoder).readString(((Utf8) oldString504)); + } else { + charSequence504 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(504, charSequence504); + } else { + throw new RuntimeException(("Illegal union index for 'F504': "+ unionIndex504)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema252(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex505 = (decoder.readIndex()); + if (unionIndex505 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(505, null); + } else { + if (unionIndex505 == 1) { + Utf8 charSequence505; + Object oldString505 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(505); + if (oldString505 instanceof Utf8) { + charSequence505 = (decoder).readString(((Utf8) oldString505)); + } else { + charSequence505 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(505, charSequence505); + } else { + throw new RuntimeException(("Illegal union index for 'F505': "+ unionIndex505)); + } + } + int unionIndex506 = (decoder.readIndex()); + if (unionIndex506 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(506, null); + } else { + if (unionIndex506 == 1) { + Utf8 charSequence506; + Object oldString506 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(506); + if (oldString506 instanceof Utf8) { + charSequence506 = (decoder).readString(((Utf8) oldString506)); + } else { + charSequence506 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(506, charSequence506); + } else { + throw new RuntimeException(("Illegal union index for 'F506': "+ unionIndex506)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema253(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex507 = (decoder.readIndex()); + if (unionIndex507 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(507, null); + } else { + if (unionIndex507 == 1) { + Utf8 charSequence507; + Object oldString507 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(507); + if (oldString507 instanceof Utf8) { + charSequence507 = (decoder).readString(((Utf8) oldString507)); + } else { + charSequence507 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(507, charSequence507); + } else { + throw new RuntimeException(("Illegal union index for 'F507': "+ unionIndex507)); + } + } + int unionIndex508 = (decoder.readIndex()); + if (unionIndex508 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(508, null); + } else { + if (unionIndex508 == 1) { + Utf8 charSequence508; + Object oldString508 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(508); + if (oldString508 instanceof Utf8) { + charSequence508 = (decoder).readString(((Utf8) oldString508)); + } else { + charSequence508 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(508, charSequence508); + } else { + throw new RuntimeException(("Illegal union index for 'F508': "+ unionIndex508)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema254(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex509 = (decoder.readIndex()); + if (unionIndex509 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(509, null); + } else { + if (unionIndex509 == 1) { + Utf8 charSequence509; + Object oldString509 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(509); + if (oldString509 instanceof Utf8) { + charSequence509 = (decoder).readString(((Utf8) oldString509)); + } else { + charSequence509 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(509, charSequence509); + } else { + throw new RuntimeException(("Illegal union index for 'F509': "+ unionIndex509)); + } + } + int unionIndex510 = (decoder.readIndex()); + if (unionIndex510 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(510, null); + } else { + if (unionIndex510 == 1) { + Utf8 charSequence510; + Object oldString510 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(510); + if (oldString510 instanceof Utf8) { + charSequence510 = (decoder).readString(((Utf8) oldString510)); + } else { + charSequence510 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(510, charSequence510); + } else { + throw new RuntimeException(("Illegal union index for 'F510': "+ unionIndex510)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema255(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex511 = (decoder.readIndex()); + if (unionIndex511 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(511, null); + } else { + if (unionIndex511 == 1) { + Utf8 charSequence511; + Object oldString511 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(511); + if (oldString511 instanceof Utf8) { + charSequence511 = (decoder).readString(((Utf8) oldString511)); + } else { + charSequence511 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(511, charSequence511); + } else { + throw new RuntimeException(("Illegal union index for 'F511': "+ unionIndex511)); + } + } + int unionIndex512 = (decoder.readIndex()); + if (unionIndex512 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(512, null); + } else { + if (unionIndex512 == 1) { + Utf8 charSequence512; + Object oldString512 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(512); + if (oldString512 instanceof Utf8) { + charSequence512 = (decoder).readString(((Utf8) oldString512)); + } else { + charSequence512 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(512, charSequence512); + } else { + throw new RuntimeException(("Illegal union index for 'F512': "+ unionIndex512)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema256(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex513 = (decoder.readIndex()); + if (unionIndex513 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(513, null); + } else { + if (unionIndex513 == 1) { + Utf8 charSequence513; + Object oldString513 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(513); + if (oldString513 instanceof Utf8) { + charSequence513 = (decoder).readString(((Utf8) oldString513)); + } else { + charSequence513 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(513, charSequence513); + } else { + throw new RuntimeException(("Illegal union index for 'F513': "+ unionIndex513)); + } + } + int unionIndex514 = (decoder.readIndex()); + if (unionIndex514 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(514, null); + } else { + if (unionIndex514 == 1) { + Utf8 charSequence514; + Object oldString514 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(514); + if (oldString514 instanceof Utf8) { + charSequence514 = (decoder).readString(((Utf8) oldString514)); + } else { + charSequence514 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(514, charSequence514); + } else { + throw new RuntimeException(("Illegal union index for 'F514': "+ unionIndex514)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema257(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex515 = (decoder.readIndex()); + if (unionIndex515 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(515, null); + } else { + if (unionIndex515 == 1) { + Utf8 charSequence515; + Object oldString515 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(515); + if (oldString515 instanceof Utf8) { + charSequence515 = (decoder).readString(((Utf8) oldString515)); + } else { + charSequence515 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(515, charSequence515); + } else { + throw new RuntimeException(("Illegal union index for 'F515': "+ unionIndex515)); + } + } + int unionIndex516 = (decoder.readIndex()); + if (unionIndex516 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(516, null); + } else { + if (unionIndex516 == 1) { + Utf8 charSequence516; + Object oldString516 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(516); + if (oldString516 instanceof Utf8) { + charSequence516 = (decoder).readString(((Utf8) oldString516)); + } else { + charSequence516 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(516, charSequence516); + } else { + throw new RuntimeException(("Illegal union index for 'F516': "+ unionIndex516)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema258(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex517 = (decoder.readIndex()); + if (unionIndex517 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(517, null); + } else { + if (unionIndex517 == 1) { + Utf8 charSequence517; + Object oldString517 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(517); + if (oldString517 instanceof Utf8) { + charSequence517 = (decoder).readString(((Utf8) oldString517)); + } else { + charSequence517 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(517, charSequence517); + } else { + throw new RuntimeException(("Illegal union index for 'F517': "+ unionIndex517)); + } + } + int unionIndex518 = (decoder.readIndex()); + if (unionIndex518 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(518, null); + } else { + if (unionIndex518 == 1) { + Utf8 charSequence518; + Object oldString518 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(518); + if (oldString518 instanceof Utf8) { + charSequence518 = (decoder).readString(((Utf8) oldString518)); + } else { + charSequence518 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(518, charSequence518); + } else { + throw new RuntimeException(("Illegal union index for 'F518': "+ unionIndex518)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema259(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex519 = (decoder.readIndex()); + if (unionIndex519 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(519, null); + } else { + if (unionIndex519 == 1) { + Utf8 charSequence519; + Object oldString519 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(519); + if (oldString519 instanceof Utf8) { + charSequence519 = (decoder).readString(((Utf8) oldString519)); + } else { + charSequence519 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(519, charSequence519); + } else { + throw new RuntimeException(("Illegal union index for 'F519': "+ unionIndex519)); + } + } + int unionIndex520 = (decoder.readIndex()); + if (unionIndex520 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(520, null); + } else { + if (unionIndex520 == 1) { + Utf8 charSequence520; + Object oldString520 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(520); + if (oldString520 instanceof Utf8) { + charSequence520 = (decoder).readString(((Utf8) oldString520)); + } else { + charSequence520 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(520, charSequence520); + } else { + throw new RuntimeException(("Illegal union index for 'F520': "+ unionIndex520)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema260(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex521 = (decoder.readIndex()); + if (unionIndex521 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(521, null); + } else { + if (unionIndex521 == 1) { + Utf8 charSequence521; + Object oldString521 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(521); + if (oldString521 instanceof Utf8) { + charSequence521 = (decoder).readString(((Utf8) oldString521)); + } else { + charSequence521 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(521, charSequence521); + } else { + throw new RuntimeException(("Illegal union index for 'F521': "+ unionIndex521)); + } + } + int unionIndex522 = (decoder.readIndex()); + if (unionIndex522 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(522, null); + } else { + if (unionIndex522 == 1) { + Utf8 charSequence522; + Object oldString522 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(522); + if (oldString522 instanceof Utf8) { + charSequence522 = (decoder).readString(((Utf8) oldString522)); + } else { + charSequence522 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(522, charSequence522); + } else { + throw new RuntimeException(("Illegal union index for 'F522': "+ unionIndex522)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema261(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex523 = (decoder.readIndex()); + if (unionIndex523 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(523, null); + } else { + if (unionIndex523 == 1) { + Utf8 charSequence523; + Object oldString523 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(523); + if (oldString523 instanceof Utf8) { + charSequence523 = (decoder).readString(((Utf8) oldString523)); + } else { + charSequence523 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(523, charSequence523); + } else { + throw new RuntimeException(("Illegal union index for 'F523': "+ unionIndex523)); + } + } + int unionIndex524 = (decoder.readIndex()); + if (unionIndex524 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(524, null); + } else { + if (unionIndex524 == 1) { + Utf8 charSequence524; + Object oldString524 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(524); + if (oldString524 instanceof Utf8) { + charSequence524 = (decoder).readString(((Utf8) oldString524)); + } else { + charSequence524 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(524, charSequence524); + } else { + throw new RuntimeException(("Illegal union index for 'F524': "+ unionIndex524)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema262(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex525 = (decoder.readIndex()); + if (unionIndex525 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(525, null); + } else { + if (unionIndex525 == 1) { + Utf8 charSequence525; + Object oldString525 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(525); + if (oldString525 instanceof Utf8) { + charSequence525 = (decoder).readString(((Utf8) oldString525)); + } else { + charSequence525 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(525, charSequence525); + } else { + throw new RuntimeException(("Illegal union index for 'F525': "+ unionIndex525)); + } + } + int unionIndex526 = (decoder.readIndex()); + if (unionIndex526 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(526, null); + } else { + if (unionIndex526 == 1) { + Utf8 charSequence526; + Object oldString526 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(526); + if (oldString526 instanceof Utf8) { + charSequence526 = (decoder).readString(((Utf8) oldString526)); + } else { + charSequence526 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(526, charSequence526); + } else { + throw new RuntimeException(("Illegal union index for 'F526': "+ unionIndex526)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema263(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex527 = (decoder.readIndex()); + if (unionIndex527 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(527, null); + } else { + if (unionIndex527 == 1) { + Utf8 charSequence527; + Object oldString527 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(527); + if (oldString527 instanceof Utf8) { + charSequence527 = (decoder).readString(((Utf8) oldString527)); + } else { + charSequence527 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(527, charSequence527); + } else { + throw new RuntimeException(("Illegal union index for 'F527': "+ unionIndex527)); + } + } + int unionIndex528 = (decoder.readIndex()); + if (unionIndex528 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(528, null); + } else { + if (unionIndex528 == 1) { + Utf8 charSequence528; + Object oldString528 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(528); + if (oldString528 instanceof Utf8) { + charSequence528 = (decoder).readString(((Utf8) oldString528)); + } else { + charSequence528 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(528, charSequence528); + } else { + throw new RuntimeException(("Illegal union index for 'F528': "+ unionIndex528)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema264(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex529 = (decoder.readIndex()); + if (unionIndex529 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(529, null); + } else { + if (unionIndex529 == 1) { + Utf8 charSequence529; + Object oldString529 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(529); + if (oldString529 instanceof Utf8) { + charSequence529 = (decoder).readString(((Utf8) oldString529)); + } else { + charSequence529 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(529, charSequence529); + } else { + throw new RuntimeException(("Illegal union index for 'F529': "+ unionIndex529)); + } + } + int unionIndex530 = (decoder.readIndex()); + if (unionIndex530 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(530, null); + } else { + if (unionIndex530 == 1) { + Utf8 charSequence530; + Object oldString530 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(530); + if (oldString530 instanceof Utf8) { + charSequence530 = (decoder).readString(((Utf8) oldString530)); + } else { + charSequence530 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(530, charSequence530); + } else { + throw new RuntimeException(("Illegal union index for 'F530': "+ unionIndex530)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema265(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex531 = (decoder.readIndex()); + if (unionIndex531 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(531, null); + } else { + if (unionIndex531 == 1) { + Utf8 charSequence531; + Object oldString531 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(531); + if (oldString531 instanceof Utf8) { + charSequence531 = (decoder).readString(((Utf8) oldString531)); + } else { + charSequence531 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(531, charSequence531); + } else { + throw new RuntimeException(("Illegal union index for 'F531': "+ unionIndex531)); + } + } + int unionIndex532 = (decoder.readIndex()); + if (unionIndex532 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(532, null); + } else { + if (unionIndex532 == 1) { + Utf8 charSequence532; + Object oldString532 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(532); + if (oldString532 instanceof Utf8) { + charSequence532 = (decoder).readString(((Utf8) oldString532)); + } else { + charSequence532 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(532, charSequence532); + } else { + throw new RuntimeException(("Illegal union index for 'F532': "+ unionIndex532)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema266(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex533 = (decoder.readIndex()); + if (unionIndex533 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(533, null); + } else { + if (unionIndex533 == 1) { + Utf8 charSequence533; + Object oldString533 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(533); + if (oldString533 instanceof Utf8) { + charSequence533 = (decoder).readString(((Utf8) oldString533)); + } else { + charSequence533 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(533, charSequence533); + } else { + throw new RuntimeException(("Illegal union index for 'F533': "+ unionIndex533)); + } + } + int unionIndex534 = (decoder.readIndex()); + if (unionIndex534 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(534, null); + } else { + if (unionIndex534 == 1) { + Utf8 charSequence534; + Object oldString534 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(534); + if (oldString534 instanceof Utf8) { + charSequence534 = (decoder).readString(((Utf8) oldString534)); + } else { + charSequence534 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(534, charSequence534); + } else { + throw new RuntimeException(("Illegal union index for 'F534': "+ unionIndex534)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema267(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex535 = (decoder.readIndex()); + if (unionIndex535 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(535, null); + } else { + if (unionIndex535 == 1) { + Utf8 charSequence535; + Object oldString535 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(535); + if (oldString535 instanceof Utf8) { + charSequence535 = (decoder).readString(((Utf8) oldString535)); + } else { + charSequence535 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(535, charSequence535); + } else { + throw new RuntimeException(("Illegal union index for 'F535': "+ unionIndex535)); + } + } + int unionIndex536 = (decoder.readIndex()); + if (unionIndex536 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(536, null); + } else { + if (unionIndex536 == 1) { + Utf8 charSequence536; + Object oldString536 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(536); + if (oldString536 instanceof Utf8) { + charSequence536 = (decoder).readString(((Utf8) oldString536)); + } else { + charSequence536 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(536, charSequence536); + } else { + throw new RuntimeException(("Illegal union index for 'F536': "+ unionIndex536)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema268(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex537 = (decoder.readIndex()); + if (unionIndex537 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(537, null); + } else { + if (unionIndex537 == 1) { + Utf8 charSequence537; + Object oldString537 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(537); + if (oldString537 instanceof Utf8) { + charSequence537 = (decoder).readString(((Utf8) oldString537)); + } else { + charSequence537 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(537, charSequence537); + } else { + throw new RuntimeException(("Illegal union index for 'F537': "+ unionIndex537)); + } + } + int unionIndex538 = (decoder.readIndex()); + if (unionIndex538 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(538, null); + } else { + if (unionIndex538 == 1) { + Utf8 charSequence538; + Object oldString538 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(538); + if (oldString538 instanceof Utf8) { + charSequence538 = (decoder).readString(((Utf8) oldString538)); + } else { + charSequence538 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(538, charSequence538); + } else { + throw new RuntimeException(("Illegal union index for 'F538': "+ unionIndex538)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema269(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex539 = (decoder.readIndex()); + if (unionIndex539 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(539, null); + } else { + if (unionIndex539 == 1) { + Utf8 charSequence539; + Object oldString539 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(539); + if (oldString539 instanceof Utf8) { + charSequence539 = (decoder).readString(((Utf8) oldString539)); + } else { + charSequence539 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(539, charSequence539); + } else { + throw new RuntimeException(("Illegal union index for 'F539': "+ unionIndex539)); + } + } + int unionIndex540 = (decoder.readIndex()); + if (unionIndex540 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(540, null); + } else { + if (unionIndex540 == 1) { + Utf8 charSequence540; + Object oldString540 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(540); + if (oldString540 instanceof Utf8) { + charSequence540 = (decoder).readString(((Utf8) oldString540)); + } else { + charSequence540 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(540, charSequence540); + } else { + throw new RuntimeException(("Illegal union index for 'F540': "+ unionIndex540)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema270(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex541 = (decoder.readIndex()); + if (unionIndex541 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(541, null); + } else { + if (unionIndex541 == 1) { + Utf8 charSequence541; + Object oldString541 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(541); + if (oldString541 instanceof Utf8) { + charSequence541 = (decoder).readString(((Utf8) oldString541)); + } else { + charSequence541 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(541, charSequence541); + } else { + throw new RuntimeException(("Illegal union index for 'F541': "+ unionIndex541)); + } + } + int unionIndex542 = (decoder.readIndex()); + if (unionIndex542 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(542, null); + } else { + if (unionIndex542 == 1) { + Utf8 charSequence542; + Object oldString542 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(542); + if (oldString542 instanceof Utf8) { + charSequence542 = (decoder).readString(((Utf8) oldString542)); + } else { + charSequence542 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(542, charSequence542); + } else { + throw new RuntimeException(("Illegal union index for 'F542': "+ unionIndex542)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema271(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex543 = (decoder.readIndex()); + if (unionIndex543 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(543, null); + } else { + if (unionIndex543 == 1) { + Utf8 charSequence543; + Object oldString543 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(543); + if (oldString543 instanceof Utf8) { + charSequence543 = (decoder).readString(((Utf8) oldString543)); + } else { + charSequence543 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(543, charSequence543); + } else { + throw new RuntimeException(("Illegal union index for 'F543': "+ unionIndex543)); + } + } + int unionIndex544 = (decoder.readIndex()); + if (unionIndex544 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(544, null); + } else { + if (unionIndex544 == 1) { + Utf8 charSequence544; + Object oldString544 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(544); + if (oldString544 instanceof Utf8) { + charSequence544 = (decoder).readString(((Utf8) oldString544)); + } else { + charSequence544 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(544, charSequence544); + } else { + throw new RuntimeException(("Illegal union index for 'F544': "+ unionIndex544)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema272(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex545 = (decoder.readIndex()); + if (unionIndex545 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(545, null); + } else { + if (unionIndex545 == 1) { + Utf8 charSequence545; + Object oldString545 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(545); + if (oldString545 instanceof Utf8) { + charSequence545 = (decoder).readString(((Utf8) oldString545)); + } else { + charSequence545 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(545, charSequence545); + } else { + throw new RuntimeException(("Illegal union index for 'F545': "+ unionIndex545)); + } + } + int unionIndex546 = (decoder.readIndex()); + if (unionIndex546 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(546, null); + } else { + if (unionIndex546 == 1) { + Utf8 charSequence546; + Object oldString546 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(546); + if (oldString546 instanceof Utf8) { + charSequence546 = (decoder).readString(((Utf8) oldString546)); + } else { + charSequence546 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(546, charSequence546); + } else { + throw new RuntimeException(("Illegal union index for 'F546': "+ unionIndex546)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema273(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex547 = (decoder.readIndex()); + if (unionIndex547 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(547, null); + } else { + if (unionIndex547 == 1) { + Utf8 charSequence547; + Object oldString547 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(547); + if (oldString547 instanceof Utf8) { + charSequence547 = (decoder).readString(((Utf8) oldString547)); + } else { + charSequence547 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(547, charSequence547); + } else { + throw new RuntimeException(("Illegal union index for 'F547': "+ unionIndex547)); + } + } + int unionIndex548 = (decoder.readIndex()); + if (unionIndex548 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(548, null); + } else { + if (unionIndex548 == 1) { + Utf8 charSequence548; + Object oldString548 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(548); + if (oldString548 instanceof Utf8) { + charSequence548 = (decoder).readString(((Utf8) oldString548)); + } else { + charSequence548 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(548, charSequence548); + } else { + throw new RuntimeException(("Illegal union index for 'F548': "+ unionIndex548)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema274(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex549 = (decoder.readIndex()); + if (unionIndex549 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(549, null); + } else { + if (unionIndex549 == 1) { + Utf8 charSequence549; + Object oldString549 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(549); + if (oldString549 instanceof Utf8) { + charSequence549 = (decoder).readString(((Utf8) oldString549)); + } else { + charSequence549 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(549, charSequence549); + } else { + throw new RuntimeException(("Illegal union index for 'F549': "+ unionIndex549)); + } + } + int unionIndex550 = (decoder.readIndex()); + if (unionIndex550 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(550, null); + } else { + if (unionIndex550 == 1) { + Utf8 charSequence550; + Object oldString550 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(550); + if (oldString550 instanceof Utf8) { + charSequence550 = (decoder).readString(((Utf8) oldString550)); + } else { + charSequence550 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(550, charSequence550); + } else { + throw new RuntimeException(("Illegal union index for 'F550': "+ unionIndex550)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema275(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex551 = (decoder.readIndex()); + if (unionIndex551 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(551, null); + } else { + if (unionIndex551 == 1) { + Utf8 charSequence551; + Object oldString551 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(551); + if (oldString551 instanceof Utf8) { + charSequence551 = (decoder).readString(((Utf8) oldString551)); + } else { + charSequence551 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(551, charSequence551); + } else { + throw new RuntimeException(("Illegal union index for 'F551': "+ unionIndex551)); + } + } + int unionIndex552 = (decoder.readIndex()); + if (unionIndex552 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(552, null); + } else { + if (unionIndex552 == 1) { + Utf8 charSequence552; + Object oldString552 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(552); + if (oldString552 instanceof Utf8) { + charSequence552 = (decoder).readString(((Utf8) oldString552)); + } else { + charSequence552 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(552, charSequence552); + } else { + throw new RuntimeException(("Illegal union index for 'F552': "+ unionIndex552)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema276(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex553 = (decoder.readIndex()); + if (unionIndex553 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(553, null); + } else { + if (unionIndex553 == 1) { + Utf8 charSequence553; + Object oldString553 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(553); + if (oldString553 instanceof Utf8) { + charSequence553 = (decoder).readString(((Utf8) oldString553)); + } else { + charSequence553 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(553, charSequence553); + } else { + throw new RuntimeException(("Illegal union index for 'F553': "+ unionIndex553)); + } + } + int unionIndex554 = (decoder.readIndex()); + if (unionIndex554 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(554, null); + } else { + if (unionIndex554 == 1) { + Utf8 charSequence554; + Object oldString554 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(554); + if (oldString554 instanceof Utf8) { + charSequence554 = (decoder).readString(((Utf8) oldString554)); + } else { + charSequence554 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(554, charSequence554); + } else { + throw new RuntimeException(("Illegal union index for 'F554': "+ unionIndex554)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema277(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex555 = (decoder.readIndex()); + if (unionIndex555 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(555, null); + } else { + if (unionIndex555 == 1) { + Utf8 charSequence555; + Object oldString555 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(555); + if (oldString555 instanceof Utf8) { + charSequence555 = (decoder).readString(((Utf8) oldString555)); + } else { + charSequence555 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(555, charSequence555); + } else { + throw new RuntimeException(("Illegal union index for 'F555': "+ unionIndex555)); + } + } + int unionIndex556 = (decoder.readIndex()); + if (unionIndex556 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(556, null); + } else { + if (unionIndex556 == 1) { + Utf8 charSequence556; + Object oldString556 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(556); + if (oldString556 instanceof Utf8) { + charSequence556 = (decoder).readString(((Utf8) oldString556)); + } else { + charSequence556 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(556, charSequence556); + } else { + throw new RuntimeException(("Illegal union index for 'F556': "+ unionIndex556)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema278(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex557 = (decoder.readIndex()); + if (unionIndex557 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(557, null); + } else { + if (unionIndex557 == 1) { + Utf8 charSequence557; + Object oldString557 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(557); + if (oldString557 instanceof Utf8) { + charSequence557 = (decoder).readString(((Utf8) oldString557)); + } else { + charSequence557 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(557, charSequence557); + } else { + throw new RuntimeException(("Illegal union index for 'F557': "+ unionIndex557)); + } + } + int unionIndex558 = (decoder.readIndex()); + if (unionIndex558 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(558, null); + } else { + if (unionIndex558 == 1) { + Utf8 charSequence558; + Object oldString558 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(558); + if (oldString558 instanceof Utf8) { + charSequence558 = (decoder).readString(((Utf8) oldString558)); + } else { + charSequence558 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(558, charSequence558); + } else { + throw new RuntimeException(("Illegal union index for 'F558': "+ unionIndex558)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema279(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex559 = (decoder.readIndex()); + if (unionIndex559 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(559, null); + } else { + if (unionIndex559 == 1) { + Utf8 charSequence559; + Object oldString559 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(559); + if (oldString559 instanceof Utf8) { + charSequence559 = (decoder).readString(((Utf8) oldString559)); + } else { + charSequence559 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(559, charSequence559); + } else { + throw new RuntimeException(("Illegal union index for 'F559': "+ unionIndex559)); + } + } + int unionIndex560 = (decoder.readIndex()); + if (unionIndex560 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(560, null); + } else { + if (unionIndex560 == 1) { + Utf8 charSequence560; + Object oldString560 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(560); + if (oldString560 instanceof Utf8) { + charSequence560 = (decoder).readString(((Utf8) oldString560)); + } else { + charSequence560 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(560, charSequence560); + } else { + throw new RuntimeException(("Illegal union index for 'F560': "+ unionIndex560)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema280(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex561 = (decoder.readIndex()); + if (unionIndex561 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(561, null); + } else { + if (unionIndex561 == 1) { + Utf8 charSequence561; + Object oldString561 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(561); + if (oldString561 instanceof Utf8) { + charSequence561 = (decoder).readString(((Utf8) oldString561)); + } else { + charSequence561 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(561, charSequence561); + } else { + throw new RuntimeException(("Illegal union index for 'F561': "+ unionIndex561)); + } + } + int unionIndex562 = (decoder.readIndex()); + if (unionIndex562 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(562, null); + } else { + if (unionIndex562 == 1) { + Utf8 charSequence562; + Object oldString562 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(562); + if (oldString562 instanceof Utf8) { + charSequence562 = (decoder).readString(((Utf8) oldString562)); + } else { + charSequence562 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(562, charSequence562); + } else { + throw new RuntimeException(("Illegal union index for 'F562': "+ unionIndex562)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema281(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex563 = (decoder.readIndex()); + if (unionIndex563 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(563, null); + } else { + if (unionIndex563 == 1) { + Utf8 charSequence563; + Object oldString563 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(563); + if (oldString563 instanceof Utf8) { + charSequence563 = (decoder).readString(((Utf8) oldString563)); + } else { + charSequence563 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(563, charSequence563); + } else { + throw new RuntimeException(("Illegal union index for 'F563': "+ unionIndex563)); + } + } + int unionIndex564 = (decoder.readIndex()); + if (unionIndex564 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(564, null); + } else { + if (unionIndex564 == 1) { + Utf8 charSequence564; + Object oldString564 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(564); + if (oldString564 instanceof Utf8) { + charSequence564 = (decoder).readString(((Utf8) oldString564)); + } else { + charSequence564 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(564, charSequence564); + } else { + throw new RuntimeException(("Illegal union index for 'F564': "+ unionIndex564)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema282(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex565 = (decoder.readIndex()); + if (unionIndex565 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(565, null); + } else { + if (unionIndex565 == 1) { + Utf8 charSequence565; + Object oldString565 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(565); + if (oldString565 instanceof Utf8) { + charSequence565 = (decoder).readString(((Utf8) oldString565)); + } else { + charSequence565 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(565, charSequence565); + } else { + throw new RuntimeException(("Illegal union index for 'F565': "+ unionIndex565)); + } + } + int unionIndex566 = (decoder.readIndex()); + if (unionIndex566 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(566, null); + } else { + if (unionIndex566 == 1) { + Utf8 charSequence566; + Object oldString566 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(566); + if (oldString566 instanceof Utf8) { + charSequence566 = (decoder).readString(((Utf8) oldString566)); + } else { + charSequence566 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(566, charSequence566); + } else { + throw new RuntimeException(("Illegal union index for 'F566': "+ unionIndex566)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema283(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex567 = (decoder.readIndex()); + if (unionIndex567 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(567, null); + } else { + if (unionIndex567 == 1) { + Utf8 charSequence567; + Object oldString567 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(567); + if (oldString567 instanceof Utf8) { + charSequence567 = (decoder).readString(((Utf8) oldString567)); + } else { + charSequence567 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(567, charSequence567); + } else { + throw new RuntimeException(("Illegal union index for 'F567': "+ unionIndex567)); + } + } + int unionIndex568 = (decoder.readIndex()); + if (unionIndex568 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(568, null); + } else { + if (unionIndex568 == 1) { + Utf8 charSequence568; + Object oldString568 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(568); + if (oldString568 instanceof Utf8) { + charSequence568 = (decoder).readString(((Utf8) oldString568)); + } else { + charSequence568 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(568, charSequence568); + } else { + throw new RuntimeException(("Illegal union index for 'F568': "+ unionIndex568)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema284(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex569 = (decoder.readIndex()); + if (unionIndex569 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(569, null); + } else { + if (unionIndex569 == 1) { + Utf8 charSequence569; + Object oldString569 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(569); + if (oldString569 instanceof Utf8) { + charSequence569 = (decoder).readString(((Utf8) oldString569)); + } else { + charSequence569 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(569, charSequence569); + } else { + throw new RuntimeException(("Illegal union index for 'F569': "+ unionIndex569)); + } + } + int unionIndex570 = (decoder.readIndex()); + if (unionIndex570 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(570, null); + } else { + if (unionIndex570 == 1) { + Utf8 charSequence570; + Object oldString570 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(570); + if (oldString570 instanceof Utf8) { + charSequence570 = (decoder).readString(((Utf8) oldString570)); + } else { + charSequence570 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(570, charSequence570); + } else { + throw new RuntimeException(("Illegal union index for 'F570': "+ unionIndex570)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema285(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex571 = (decoder.readIndex()); + if (unionIndex571 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(571, null); + } else { + if (unionIndex571 == 1) { + Utf8 charSequence571; + Object oldString571 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(571); + if (oldString571 instanceof Utf8) { + charSequence571 = (decoder).readString(((Utf8) oldString571)); + } else { + charSequence571 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(571, charSequence571); + } else { + throw new RuntimeException(("Illegal union index for 'F571': "+ unionIndex571)); + } + } + int unionIndex572 = (decoder.readIndex()); + if (unionIndex572 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(572, null); + } else { + if (unionIndex572 == 1) { + Utf8 charSequence572; + Object oldString572 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(572); + if (oldString572 instanceof Utf8) { + charSequence572 = (decoder).readString(((Utf8) oldString572)); + } else { + charSequence572 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(572, charSequence572); + } else { + throw new RuntimeException(("Illegal union index for 'F572': "+ unionIndex572)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema286(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex573 = (decoder.readIndex()); + if (unionIndex573 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(573, null); + } else { + if (unionIndex573 == 1) { + Utf8 charSequence573; + Object oldString573 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(573); + if (oldString573 instanceof Utf8) { + charSequence573 = (decoder).readString(((Utf8) oldString573)); + } else { + charSequence573 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(573, charSequence573); + } else { + throw new RuntimeException(("Illegal union index for 'F573': "+ unionIndex573)); + } + } + int unionIndex574 = (decoder.readIndex()); + if (unionIndex574 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(574, null); + } else { + if (unionIndex574 == 1) { + Utf8 charSequence574; + Object oldString574 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(574); + if (oldString574 instanceof Utf8) { + charSequence574 = (decoder).readString(((Utf8) oldString574)); + } else { + charSequence574 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(574, charSequence574); + } else { + throw new RuntimeException(("Illegal union index for 'F574': "+ unionIndex574)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema287(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex575 = (decoder.readIndex()); + if (unionIndex575 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(575, null); + } else { + if (unionIndex575 == 1) { + Utf8 charSequence575; + Object oldString575 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(575); + if (oldString575 instanceof Utf8) { + charSequence575 = (decoder).readString(((Utf8) oldString575)); + } else { + charSequence575 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(575, charSequence575); + } else { + throw new RuntimeException(("Illegal union index for 'F575': "+ unionIndex575)); + } + } + int unionIndex576 = (decoder.readIndex()); + if (unionIndex576 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(576, null); + } else { + if (unionIndex576 == 1) { + Utf8 charSequence576; + Object oldString576 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(576); + if (oldString576 instanceof Utf8) { + charSequence576 = (decoder).readString(((Utf8) oldString576)); + } else { + charSequence576 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(576, charSequence576); + } else { + throw new RuntimeException(("Illegal union index for 'F576': "+ unionIndex576)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema288(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex577 = (decoder.readIndex()); + if (unionIndex577 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(577, null); + } else { + if (unionIndex577 == 1) { + Utf8 charSequence577; + Object oldString577 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(577); + if (oldString577 instanceof Utf8) { + charSequence577 = (decoder).readString(((Utf8) oldString577)); + } else { + charSequence577 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(577, charSequence577); + } else { + throw new RuntimeException(("Illegal union index for 'F577': "+ unionIndex577)); + } + } + int unionIndex578 = (decoder.readIndex()); + if (unionIndex578 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(578, null); + } else { + if (unionIndex578 == 1) { + Utf8 charSequence578; + Object oldString578 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(578); + if (oldString578 instanceof Utf8) { + charSequence578 = (decoder).readString(((Utf8) oldString578)); + } else { + charSequence578 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(578, charSequence578); + } else { + throw new RuntimeException(("Illegal union index for 'F578': "+ unionIndex578)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema289(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex579 = (decoder.readIndex()); + if (unionIndex579 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(579, null); + } else { + if (unionIndex579 == 1) { + Utf8 charSequence579; + Object oldString579 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(579); + if (oldString579 instanceof Utf8) { + charSequence579 = (decoder).readString(((Utf8) oldString579)); + } else { + charSequence579 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(579, charSequence579); + } else { + throw new RuntimeException(("Illegal union index for 'F579': "+ unionIndex579)); + } + } + int unionIndex580 = (decoder.readIndex()); + if (unionIndex580 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(580, null); + } else { + if (unionIndex580 == 1) { + Utf8 charSequence580; + Object oldString580 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(580); + if (oldString580 instanceof Utf8) { + charSequence580 = (decoder).readString(((Utf8) oldString580)); + } else { + charSequence580 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(580, charSequence580); + } else { + throw new RuntimeException(("Illegal union index for 'F580': "+ unionIndex580)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema290(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex581 = (decoder.readIndex()); + if (unionIndex581 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(581, null); + } else { + if (unionIndex581 == 1) { + Utf8 charSequence581; + Object oldString581 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(581); + if (oldString581 instanceof Utf8) { + charSequence581 = (decoder).readString(((Utf8) oldString581)); + } else { + charSequence581 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(581, charSequence581); + } else { + throw new RuntimeException(("Illegal union index for 'F581': "+ unionIndex581)); + } + } + int unionIndex582 = (decoder.readIndex()); + if (unionIndex582 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(582, null); + } else { + if (unionIndex582 == 1) { + Utf8 charSequence582; + Object oldString582 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(582); + if (oldString582 instanceof Utf8) { + charSequence582 = (decoder).readString(((Utf8) oldString582)); + } else { + charSequence582 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(582, charSequence582); + } else { + throw new RuntimeException(("Illegal union index for 'F582': "+ unionIndex582)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema291(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex583 = (decoder.readIndex()); + if (unionIndex583 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(583, null); + } else { + if (unionIndex583 == 1) { + Utf8 charSequence583; + Object oldString583 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(583); + if (oldString583 instanceof Utf8) { + charSequence583 = (decoder).readString(((Utf8) oldString583)); + } else { + charSequence583 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(583, charSequence583); + } else { + throw new RuntimeException(("Illegal union index for 'F583': "+ unionIndex583)); + } + } + int unionIndex584 = (decoder.readIndex()); + if (unionIndex584 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(584, null); + } else { + if (unionIndex584 == 1) { + Utf8 charSequence584; + Object oldString584 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(584); + if (oldString584 instanceof Utf8) { + charSequence584 = (decoder).readString(((Utf8) oldString584)); + } else { + charSequence584 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(584, charSequence584); + } else { + throw new RuntimeException(("Illegal union index for 'F584': "+ unionIndex584)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema292(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex585 = (decoder.readIndex()); + if (unionIndex585 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(585, null); + } else { + if (unionIndex585 == 1) { + Utf8 charSequence585; + Object oldString585 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(585); + if (oldString585 instanceof Utf8) { + charSequence585 = (decoder).readString(((Utf8) oldString585)); + } else { + charSequence585 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(585, charSequence585); + } else { + throw new RuntimeException(("Illegal union index for 'F585': "+ unionIndex585)); + } + } + int unionIndex586 = (decoder.readIndex()); + if (unionIndex586 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(586, null); + } else { + if (unionIndex586 == 1) { + Utf8 charSequence586; + Object oldString586 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(586); + if (oldString586 instanceof Utf8) { + charSequence586 = (decoder).readString(((Utf8) oldString586)); + } else { + charSequence586 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(586, charSequence586); + } else { + throw new RuntimeException(("Illegal union index for 'F586': "+ unionIndex586)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema293(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex587 = (decoder.readIndex()); + if (unionIndex587 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(587, null); + } else { + if (unionIndex587 == 1) { + Utf8 charSequence587; + Object oldString587 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(587); + if (oldString587 instanceof Utf8) { + charSequence587 = (decoder).readString(((Utf8) oldString587)); + } else { + charSequence587 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(587, charSequence587); + } else { + throw new RuntimeException(("Illegal union index for 'F587': "+ unionIndex587)); + } + } + int unionIndex588 = (decoder.readIndex()); + if (unionIndex588 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(588, null); + } else { + if (unionIndex588 == 1) { + Utf8 charSequence588; + Object oldString588 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(588); + if (oldString588 instanceof Utf8) { + charSequence588 = (decoder).readString(((Utf8) oldString588)); + } else { + charSequence588 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(588, charSequence588); + } else { + throw new RuntimeException(("Illegal union index for 'F588': "+ unionIndex588)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema294(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex589 = (decoder.readIndex()); + if (unionIndex589 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(589, null); + } else { + if (unionIndex589 == 1) { + Utf8 charSequence589; + Object oldString589 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(589); + if (oldString589 instanceof Utf8) { + charSequence589 = (decoder).readString(((Utf8) oldString589)); + } else { + charSequence589 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(589, charSequence589); + } else { + throw new RuntimeException(("Illegal union index for 'F589': "+ unionIndex589)); + } + } + int unionIndex590 = (decoder.readIndex()); + if (unionIndex590 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(590, null); + } else { + if (unionIndex590 == 1) { + Utf8 charSequence590; + Object oldString590 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(590); + if (oldString590 instanceof Utf8) { + charSequence590 = (decoder).readString(((Utf8) oldString590)); + } else { + charSequence590 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(590, charSequence590); + } else { + throw new RuntimeException(("Illegal union index for 'F590': "+ unionIndex590)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema295(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex591 = (decoder.readIndex()); + if (unionIndex591 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(591, null); + } else { + if (unionIndex591 == 1) { + Utf8 charSequence591; + Object oldString591 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(591); + if (oldString591 instanceof Utf8) { + charSequence591 = (decoder).readString(((Utf8) oldString591)); + } else { + charSequence591 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(591, charSequence591); + } else { + throw new RuntimeException(("Illegal union index for 'F591': "+ unionIndex591)); + } + } + int unionIndex592 = (decoder.readIndex()); + if (unionIndex592 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(592, null); + } else { + if (unionIndex592 == 1) { + Utf8 charSequence592; + Object oldString592 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(592); + if (oldString592 instanceof Utf8) { + charSequence592 = (decoder).readString(((Utf8) oldString592)); + } else { + charSequence592 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(592, charSequence592); + } else { + throw new RuntimeException(("Illegal union index for 'F592': "+ unionIndex592)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema296(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex593 = (decoder.readIndex()); + if (unionIndex593 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(593, null); + } else { + if (unionIndex593 == 1) { + Utf8 charSequence593; + Object oldString593 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(593); + if (oldString593 instanceof Utf8) { + charSequence593 = (decoder).readString(((Utf8) oldString593)); + } else { + charSequence593 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(593, charSequence593); + } else { + throw new RuntimeException(("Illegal union index for 'F593': "+ unionIndex593)); + } + } + int unionIndex594 = (decoder.readIndex()); + if (unionIndex594 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(594, null); + } else { + if (unionIndex594 == 1) { + Utf8 charSequence594; + Object oldString594 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(594); + if (oldString594 instanceof Utf8) { + charSequence594 = (decoder).readString(((Utf8) oldString594)); + } else { + charSequence594 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(594, charSequence594); + } else { + throw new RuntimeException(("Illegal union index for 'F594': "+ unionIndex594)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema297(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex595 = (decoder.readIndex()); + if (unionIndex595 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(595, null); + } else { + if (unionIndex595 == 1) { + Utf8 charSequence595; + Object oldString595 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(595); + if (oldString595 instanceof Utf8) { + charSequence595 = (decoder).readString(((Utf8) oldString595)); + } else { + charSequence595 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(595, charSequence595); + } else { + throw new RuntimeException(("Illegal union index for 'F595': "+ unionIndex595)); + } + } + int unionIndex596 = (decoder.readIndex()); + if (unionIndex596 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(596, null); + } else { + if (unionIndex596 == 1) { + Utf8 charSequence596; + Object oldString596 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(596); + if (oldString596 instanceof Utf8) { + charSequence596 = (decoder).readString(((Utf8) oldString596)); + } else { + charSequence596 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(596, charSequence596); + } else { + throw new RuntimeException(("Illegal union index for 'F596': "+ unionIndex596)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema298(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex597 = (decoder.readIndex()); + if (unionIndex597 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(597, null); + } else { + if (unionIndex597 == 1) { + Utf8 charSequence597; + Object oldString597 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(597); + if (oldString597 instanceof Utf8) { + charSequence597 = (decoder).readString(((Utf8) oldString597)); + } else { + charSequence597 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(597, charSequence597); + } else { + throw new RuntimeException(("Illegal union index for 'F597': "+ unionIndex597)); + } + } + int unionIndex598 = (decoder.readIndex()); + if (unionIndex598 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(598, null); + } else { + if (unionIndex598 == 1) { + Utf8 charSequence598; + Object oldString598 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(598); + if (oldString598 instanceof Utf8) { + charSequence598 = (decoder).readString(((Utf8) oldString598)); + } else { + charSequence598 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(598, charSequence598); + } else { + throw new RuntimeException(("Illegal union index for 'F598': "+ unionIndex598)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema299(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex599 = (decoder.readIndex()); + if (unionIndex599 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(599, null); + } else { + if (unionIndex599 == 1) { + Utf8 charSequence599; + Object oldString599 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(599); + if (oldString599 instanceof Utf8) { + charSequence599 = (decoder).readString(((Utf8) oldString599)); + } else { + charSequence599 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(599, charSequence599); + } else { + throw new RuntimeException(("Illegal union index for 'F599': "+ unionIndex599)); + } + } + int unionIndex600 = (decoder.readIndex()); + if (unionIndex600 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(600, null); + } else { + if (unionIndex600 == 1) { + Utf8 charSequence600; + Object oldString600 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(600); + if (oldString600 instanceof Utf8) { + charSequence600 = (decoder).readString(((Utf8) oldString600)); + } else { + charSequence600 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(600, charSequence600); + } else { + throw new RuntimeException(("Illegal union index for 'F600': "+ unionIndex600)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema300(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex601 = (decoder.readIndex()); + if (unionIndex601 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(601, null); + } else { + if (unionIndex601 == 1) { + Utf8 charSequence601; + Object oldString601 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(601); + if (oldString601 instanceof Utf8) { + charSequence601 = (decoder).readString(((Utf8) oldString601)); + } else { + charSequence601 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(601, charSequence601); + } else { + throw new RuntimeException(("Illegal union index for 'F601': "+ unionIndex601)); + } + } + int unionIndex602 = (decoder.readIndex()); + if (unionIndex602 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(602, null); + } else { + if (unionIndex602 == 1) { + Utf8 charSequence602; + Object oldString602 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(602); + if (oldString602 instanceof Utf8) { + charSequence602 = (decoder).readString(((Utf8) oldString602)); + } else { + charSequence602 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(602, charSequence602); + } else { + throw new RuntimeException(("Illegal union index for 'F602': "+ unionIndex602)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema301(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex603 = (decoder.readIndex()); + if (unionIndex603 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(603, null); + } else { + if (unionIndex603 == 1) { + Utf8 charSequence603; + Object oldString603 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(603); + if (oldString603 instanceof Utf8) { + charSequence603 = (decoder).readString(((Utf8) oldString603)); + } else { + charSequence603 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(603, charSequence603); + } else { + throw new RuntimeException(("Illegal union index for 'F603': "+ unionIndex603)); + } + } + int unionIndex604 = (decoder.readIndex()); + if (unionIndex604 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(604, null); + } else { + if (unionIndex604 == 1) { + Utf8 charSequence604; + Object oldString604 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(604); + if (oldString604 instanceof Utf8) { + charSequence604 = (decoder).readString(((Utf8) oldString604)); + } else { + charSequence604 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(604, charSequence604); + } else { + throw new RuntimeException(("Illegal union index for 'F604': "+ unionIndex604)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema302(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex605 = (decoder.readIndex()); + if (unionIndex605 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(605, null); + } else { + if (unionIndex605 == 1) { + Utf8 charSequence605; + Object oldString605 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(605); + if (oldString605 instanceof Utf8) { + charSequence605 = (decoder).readString(((Utf8) oldString605)); + } else { + charSequence605 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(605, charSequence605); + } else { + throw new RuntimeException(("Illegal union index for 'F605': "+ unionIndex605)); + } + } + int unionIndex606 = (decoder.readIndex()); + if (unionIndex606 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(606, null); + } else { + if (unionIndex606 == 1) { + Utf8 charSequence606; + Object oldString606 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(606); + if (oldString606 instanceof Utf8) { + charSequence606 = (decoder).readString(((Utf8) oldString606)); + } else { + charSequence606 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(606, charSequence606); + } else { + throw new RuntimeException(("Illegal union index for 'F606': "+ unionIndex606)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema303(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex607 = (decoder.readIndex()); + if (unionIndex607 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(607, null); + } else { + if (unionIndex607 == 1) { + Utf8 charSequence607; + Object oldString607 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(607); + if (oldString607 instanceof Utf8) { + charSequence607 = (decoder).readString(((Utf8) oldString607)); + } else { + charSequence607 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(607, charSequence607); + } else { + throw new RuntimeException(("Illegal union index for 'F607': "+ unionIndex607)); + } + } + int unionIndex608 = (decoder.readIndex()); + if (unionIndex608 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(608, null); + } else { + if (unionIndex608 == 1) { + Utf8 charSequence608; + Object oldString608 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(608); + if (oldString608 instanceof Utf8) { + charSequence608 = (decoder).readString(((Utf8) oldString608)); + } else { + charSequence608 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(608, charSequence608); + } else { + throw new RuntimeException(("Illegal union index for 'F608': "+ unionIndex608)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema304(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex609 = (decoder.readIndex()); + if (unionIndex609 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(609, null); + } else { + if (unionIndex609 == 1) { + Utf8 charSequence609; + Object oldString609 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(609); + if (oldString609 instanceof Utf8) { + charSequence609 = (decoder).readString(((Utf8) oldString609)); + } else { + charSequence609 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(609, charSequence609); + } else { + throw new RuntimeException(("Illegal union index for 'F609': "+ unionIndex609)); + } + } + int unionIndex610 = (decoder.readIndex()); + if (unionIndex610 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(610, null); + } else { + if (unionIndex610 == 1) { + Utf8 charSequence610; + Object oldString610 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(610); + if (oldString610 instanceof Utf8) { + charSequence610 = (decoder).readString(((Utf8) oldString610)); + } else { + charSequence610 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(610, charSequence610); + } else { + throw new RuntimeException(("Illegal union index for 'F610': "+ unionIndex610)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema305(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex611 = (decoder.readIndex()); + if (unionIndex611 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(611, null); + } else { + if (unionIndex611 == 1) { + Utf8 charSequence611; + Object oldString611 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(611); + if (oldString611 instanceof Utf8) { + charSequence611 = (decoder).readString(((Utf8) oldString611)); + } else { + charSequence611 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(611, charSequence611); + } else { + throw new RuntimeException(("Illegal union index for 'F611': "+ unionIndex611)); + } + } + int unionIndex612 = (decoder.readIndex()); + if (unionIndex612 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(612, null); + } else { + if (unionIndex612 == 1) { + Utf8 charSequence612; + Object oldString612 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(612); + if (oldString612 instanceof Utf8) { + charSequence612 = (decoder).readString(((Utf8) oldString612)); + } else { + charSequence612 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(612, charSequence612); + } else { + throw new RuntimeException(("Illegal union index for 'F612': "+ unionIndex612)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema306(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex613 = (decoder.readIndex()); + if (unionIndex613 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(613, null); + } else { + if (unionIndex613 == 1) { + Utf8 charSequence613; + Object oldString613 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(613); + if (oldString613 instanceof Utf8) { + charSequence613 = (decoder).readString(((Utf8) oldString613)); + } else { + charSequence613 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(613, charSequence613); + } else { + throw new RuntimeException(("Illegal union index for 'F613': "+ unionIndex613)); + } + } + int unionIndex614 = (decoder.readIndex()); + if (unionIndex614 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(614, null); + } else { + if (unionIndex614 == 1) { + Utf8 charSequence614; + Object oldString614 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(614); + if (oldString614 instanceof Utf8) { + charSequence614 = (decoder).readString(((Utf8) oldString614)); + } else { + charSequence614 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(614, charSequence614); + } else { + throw new RuntimeException(("Illegal union index for 'F614': "+ unionIndex614)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema307(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex615 = (decoder.readIndex()); + if (unionIndex615 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(615, null); + } else { + if (unionIndex615 == 1) { + Utf8 charSequence615; + Object oldString615 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(615); + if (oldString615 instanceof Utf8) { + charSequence615 = (decoder).readString(((Utf8) oldString615)); + } else { + charSequence615 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(615, charSequence615); + } else { + throw new RuntimeException(("Illegal union index for 'F615': "+ unionIndex615)); + } + } + int unionIndex616 = (decoder.readIndex()); + if (unionIndex616 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(616, null); + } else { + if (unionIndex616 == 1) { + Utf8 charSequence616; + Object oldString616 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(616); + if (oldString616 instanceof Utf8) { + charSequence616 = (decoder).readString(((Utf8) oldString616)); + } else { + charSequence616 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(616, charSequence616); + } else { + throw new RuntimeException(("Illegal union index for 'F616': "+ unionIndex616)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema308(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex617 = (decoder.readIndex()); + if (unionIndex617 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(617, null); + } else { + if (unionIndex617 == 1) { + Utf8 charSequence617; + Object oldString617 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(617); + if (oldString617 instanceof Utf8) { + charSequence617 = (decoder).readString(((Utf8) oldString617)); + } else { + charSequence617 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(617, charSequence617); + } else { + throw new RuntimeException(("Illegal union index for 'F617': "+ unionIndex617)); + } + } + int unionIndex618 = (decoder.readIndex()); + if (unionIndex618 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(618, null); + } else { + if (unionIndex618 == 1) { + Utf8 charSequence618; + Object oldString618 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(618); + if (oldString618 instanceof Utf8) { + charSequence618 = (decoder).readString(((Utf8) oldString618)); + } else { + charSequence618 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(618, charSequence618); + } else { + throw new RuntimeException(("Illegal union index for 'F618': "+ unionIndex618)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema309(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex619 = (decoder.readIndex()); + if (unionIndex619 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(619, null); + } else { + if (unionIndex619 == 1) { + Utf8 charSequence619; + Object oldString619 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(619); + if (oldString619 instanceof Utf8) { + charSequence619 = (decoder).readString(((Utf8) oldString619)); + } else { + charSequence619 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(619, charSequence619); + } else { + throw new RuntimeException(("Illegal union index for 'F619': "+ unionIndex619)); + } + } + int unionIndex620 = (decoder.readIndex()); + if (unionIndex620 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(620, null); + } else { + if (unionIndex620 == 1) { + Utf8 charSequence620; + Object oldString620 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(620); + if (oldString620 instanceof Utf8) { + charSequence620 = (decoder).readString(((Utf8) oldString620)); + } else { + charSequence620 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(620, charSequence620); + } else { + throw new RuntimeException(("Illegal union index for 'F620': "+ unionIndex620)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema310(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex621 = (decoder.readIndex()); + if (unionIndex621 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(621, null); + } else { + if (unionIndex621 == 1) { + Utf8 charSequence621; + Object oldString621 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(621); + if (oldString621 instanceof Utf8) { + charSequence621 = (decoder).readString(((Utf8) oldString621)); + } else { + charSequence621 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(621, charSequence621); + } else { + throw new RuntimeException(("Illegal union index for 'F621': "+ unionIndex621)); + } + } + int unionIndex622 = (decoder.readIndex()); + if (unionIndex622 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(622, null); + } else { + if (unionIndex622 == 1) { + Utf8 charSequence622; + Object oldString622 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(622); + if (oldString622 instanceof Utf8) { + charSequence622 = (decoder).readString(((Utf8) oldString622)); + } else { + charSequence622 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(622, charSequence622); + } else { + throw new RuntimeException(("Illegal union index for 'F622': "+ unionIndex622)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema311(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex623 = (decoder.readIndex()); + if (unionIndex623 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(623, null); + } else { + if (unionIndex623 == 1) { + Utf8 charSequence623; + Object oldString623 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(623); + if (oldString623 instanceof Utf8) { + charSequence623 = (decoder).readString(((Utf8) oldString623)); + } else { + charSequence623 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(623, charSequence623); + } else { + throw new RuntimeException(("Illegal union index for 'F623': "+ unionIndex623)); + } + } + int unionIndex624 = (decoder.readIndex()); + if (unionIndex624 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(624, null); + } else { + if (unionIndex624 == 1) { + Utf8 charSequence624; + Object oldString624 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(624); + if (oldString624 instanceof Utf8) { + charSequence624 = (decoder).readString(((Utf8) oldString624)); + } else { + charSequence624 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(624, charSequence624); + } else { + throw new RuntimeException(("Illegal union index for 'F624': "+ unionIndex624)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema312(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex625 = (decoder.readIndex()); + if (unionIndex625 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(625, null); + } else { + if (unionIndex625 == 1) { + Utf8 charSequence625; + Object oldString625 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(625); + if (oldString625 instanceof Utf8) { + charSequence625 = (decoder).readString(((Utf8) oldString625)); + } else { + charSequence625 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(625, charSequence625); + } else { + throw new RuntimeException(("Illegal union index for 'F625': "+ unionIndex625)); + } + } + int unionIndex626 = (decoder.readIndex()); + if (unionIndex626 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(626, null); + } else { + if (unionIndex626 == 1) { + Utf8 charSequence626; + Object oldString626 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(626); + if (oldString626 instanceof Utf8) { + charSequence626 = (decoder).readString(((Utf8) oldString626)); + } else { + charSequence626 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(626, charSequence626); + } else { + throw new RuntimeException(("Illegal union index for 'F626': "+ unionIndex626)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema313(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex627 = (decoder.readIndex()); + if (unionIndex627 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(627, null); + } else { + if (unionIndex627 == 1) { + Utf8 charSequence627; + Object oldString627 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(627); + if (oldString627 instanceof Utf8) { + charSequence627 = (decoder).readString(((Utf8) oldString627)); + } else { + charSequence627 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(627, charSequence627); + } else { + throw new RuntimeException(("Illegal union index for 'F627': "+ unionIndex627)); + } + } + int unionIndex628 = (decoder.readIndex()); + if (unionIndex628 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(628, null); + } else { + if (unionIndex628 == 1) { + Utf8 charSequence628; + Object oldString628 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(628); + if (oldString628 instanceof Utf8) { + charSequence628 = (decoder).readString(((Utf8) oldString628)); + } else { + charSequence628 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(628, charSequence628); + } else { + throw new RuntimeException(("Illegal union index for 'F628': "+ unionIndex628)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema314(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex629 = (decoder.readIndex()); + if (unionIndex629 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(629, null); + } else { + if (unionIndex629 == 1) { + Utf8 charSequence629; + Object oldString629 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(629); + if (oldString629 instanceof Utf8) { + charSequence629 = (decoder).readString(((Utf8) oldString629)); + } else { + charSequence629 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(629, charSequence629); + } else { + throw new RuntimeException(("Illegal union index for 'F629': "+ unionIndex629)); + } + } + int unionIndex630 = (decoder.readIndex()); + if (unionIndex630 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(630, null); + } else { + if (unionIndex630 == 1) { + Utf8 charSequence630; + Object oldString630 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(630); + if (oldString630 instanceof Utf8) { + charSequence630 = (decoder).readString(((Utf8) oldString630)); + } else { + charSequence630 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(630, charSequence630); + } else { + throw new RuntimeException(("Illegal union index for 'F630': "+ unionIndex630)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema315(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex631 = (decoder.readIndex()); + if (unionIndex631 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(631, null); + } else { + if (unionIndex631 == 1) { + Utf8 charSequence631; + Object oldString631 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(631); + if (oldString631 instanceof Utf8) { + charSequence631 = (decoder).readString(((Utf8) oldString631)); + } else { + charSequence631 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(631, charSequence631); + } else { + throw new RuntimeException(("Illegal union index for 'F631': "+ unionIndex631)); + } + } + int unionIndex632 = (decoder.readIndex()); + if (unionIndex632 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(632, null); + } else { + if (unionIndex632 == 1) { + Utf8 charSequence632; + Object oldString632 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(632); + if (oldString632 instanceof Utf8) { + charSequence632 = (decoder).readString(((Utf8) oldString632)); + } else { + charSequence632 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(632, charSequence632); + } else { + throw new RuntimeException(("Illegal union index for 'F632': "+ unionIndex632)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema316(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex633 = (decoder.readIndex()); + if (unionIndex633 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(633, null); + } else { + if (unionIndex633 == 1) { + Utf8 charSequence633; + Object oldString633 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(633); + if (oldString633 instanceof Utf8) { + charSequence633 = (decoder).readString(((Utf8) oldString633)); + } else { + charSequence633 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(633, charSequence633); + } else { + throw new RuntimeException(("Illegal union index for 'F633': "+ unionIndex633)); + } + } + int unionIndex634 = (decoder.readIndex()); + if (unionIndex634 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(634, null); + } else { + if (unionIndex634 == 1) { + Utf8 charSequence634; + Object oldString634 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(634); + if (oldString634 instanceof Utf8) { + charSequence634 = (decoder).readString(((Utf8) oldString634)); + } else { + charSequence634 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(634, charSequence634); + } else { + throw new RuntimeException(("Illegal union index for 'F634': "+ unionIndex634)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema317(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex635 = (decoder.readIndex()); + if (unionIndex635 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(635, null); + } else { + if (unionIndex635 == 1) { + Utf8 charSequence635; + Object oldString635 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(635); + if (oldString635 instanceof Utf8) { + charSequence635 = (decoder).readString(((Utf8) oldString635)); + } else { + charSequence635 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(635, charSequence635); + } else { + throw new RuntimeException(("Illegal union index for 'F635': "+ unionIndex635)); + } + } + int unionIndex636 = (decoder.readIndex()); + if (unionIndex636 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(636, null); + } else { + if (unionIndex636 == 1) { + Utf8 charSequence636; + Object oldString636 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(636); + if (oldString636 instanceof Utf8) { + charSequence636 = (decoder).readString(((Utf8) oldString636)); + } else { + charSequence636 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(636, charSequence636); + } else { + throw new RuntimeException(("Illegal union index for 'F636': "+ unionIndex636)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema318(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex637 = (decoder.readIndex()); + if (unionIndex637 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(637, null); + } else { + if (unionIndex637 == 1) { + Utf8 charSequence637; + Object oldString637 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(637); + if (oldString637 instanceof Utf8) { + charSequence637 = (decoder).readString(((Utf8) oldString637)); + } else { + charSequence637 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(637, charSequence637); + } else { + throw new RuntimeException(("Illegal union index for 'F637': "+ unionIndex637)); + } + } + int unionIndex638 = (decoder.readIndex()); + if (unionIndex638 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(638, null); + } else { + if (unionIndex638 == 1) { + Utf8 charSequence638; + Object oldString638 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(638); + if (oldString638 instanceof Utf8) { + charSequence638 = (decoder).readString(((Utf8) oldString638)); + } else { + charSequence638 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(638, charSequence638); + } else { + throw new RuntimeException(("Illegal union index for 'F638': "+ unionIndex638)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema319(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex639 = (decoder.readIndex()); + if (unionIndex639 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(639, null); + } else { + if (unionIndex639 == 1) { + Utf8 charSequence639; + Object oldString639 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(639); + if (oldString639 instanceof Utf8) { + charSequence639 = (decoder).readString(((Utf8) oldString639)); + } else { + charSequence639 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(639, charSequence639); + } else { + throw new RuntimeException(("Illegal union index for 'F639': "+ unionIndex639)); + } + } + int unionIndex640 = (decoder.readIndex()); + if (unionIndex640 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(640, null); + } else { + if (unionIndex640 == 1) { + Utf8 charSequence640; + Object oldString640 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(640); + if (oldString640 instanceof Utf8) { + charSequence640 = (decoder).readString(((Utf8) oldString640)); + } else { + charSequence640 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(640, charSequence640); + } else { + throw new RuntimeException(("Illegal union index for 'F640': "+ unionIndex640)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema320(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex641 = (decoder.readIndex()); + if (unionIndex641 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(641, null); + } else { + if (unionIndex641 == 1) { + Utf8 charSequence641; + Object oldString641 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(641); + if (oldString641 instanceof Utf8) { + charSequence641 = (decoder).readString(((Utf8) oldString641)); + } else { + charSequence641 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(641, charSequence641); + } else { + throw new RuntimeException(("Illegal union index for 'F641': "+ unionIndex641)); + } + } + int unionIndex642 = (decoder.readIndex()); + if (unionIndex642 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(642, null); + } else { + if (unionIndex642 == 1) { + Utf8 charSequence642; + Object oldString642 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(642); + if (oldString642 instanceof Utf8) { + charSequence642 = (decoder).readString(((Utf8) oldString642)); + } else { + charSequence642 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(642, charSequence642); + } else { + throw new RuntimeException(("Illegal union index for 'F642': "+ unionIndex642)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema321(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex643 = (decoder.readIndex()); + if (unionIndex643 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(643, null); + } else { + if (unionIndex643 == 1) { + Utf8 charSequence643; + Object oldString643 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(643); + if (oldString643 instanceof Utf8) { + charSequence643 = (decoder).readString(((Utf8) oldString643)); + } else { + charSequence643 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(643, charSequence643); + } else { + throw new RuntimeException(("Illegal union index for 'F643': "+ unionIndex643)); + } + } + int unionIndex644 = (decoder.readIndex()); + if (unionIndex644 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(644, null); + } else { + if (unionIndex644 == 1) { + Utf8 charSequence644; + Object oldString644 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(644); + if (oldString644 instanceof Utf8) { + charSequence644 = (decoder).readString(((Utf8) oldString644)); + } else { + charSequence644 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(644, charSequence644); + } else { + throw new RuntimeException(("Illegal union index for 'F644': "+ unionIndex644)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema322(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex645 = (decoder.readIndex()); + if (unionIndex645 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(645, null); + } else { + if (unionIndex645 == 1) { + Utf8 charSequence645; + Object oldString645 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(645); + if (oldString645 instanceof Utf8) { + charSequence645 = (decoder).readString(((Utf8) oldString645)); + } else { + charSequence645 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(645, charSequence645); + } else { + throw new RuntimeException(("Illegal union index for 'F645': "+ unionIndex645)); + } + } + int unionIndex646 = (decoder.readIndex()); + if (unionIndex646 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(646, null); + } else { + if (unionIndex646 == 1) { + Utf8 charSequence646; + Object oldString646 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(646); + if (oldString646 instanceof Utf8) { + charSequence646 = (decoder).readString(((Utf8) oldString646)); + } else { + charSequence646 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(646, charSequence646); + } else { + throw new RuntimeException(("Illegal union index for 'F646': "+ unionIndex646)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema323(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex647 = (decoder.readIndex()); + if (unionIndex647 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(647, null); + } else { + if (unionIndex647 == 1) { + Utf8 charSequence647; + Object oldString647 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(647); + if (oldString647 instanceof Utf8) { + charSequence647 = (decoder).readString(((Utf8) oldString647)); + } else { + charSequence647 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(647, charSequence647); + } else { + throw new RuntimeException(("Illegal union index for 'F647': "+ unionIndex647)); + } + } + int unionIndex648 = (decoder.readIndex()); + if (unionIndex648 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(648, null); + } else { + if (unionIndex648 == 1) { + Utf8 charSequence648; + Object oldString648 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(648); + if (oldString648 instanceof Utf8) { + charSequence648 = (decoder).readString(((Utf8) oldString648)); + } else { + charSequence648 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(648, charSequence648); + } else { + throw new RuntimeException(("Illegal union index for 'F648': "+ unionIndex648)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema324(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex649 = (decoder.readIndex()); + if (unionIndex649 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(649, null); + } else { + if (unionIndex649 == 1) { + Utf8 charSequence649; + Object oldString649 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(649); + if (oldString649 instanceof Utf8) { + charSequence649 = (decoder).readString(((Utf8) oldString649)); + } else { + charSequence649 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(649, charSequence649); + } else { + throw new RuntimeException(("Illegal union index for 'F649': "+ unionIndex649)); + } + } + int unionIndex650 = (decoder.readIndex()); + if (unionIndex650 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(650, null); + } else { + if (unionIndex650 == 1) { + Utf8 charSequence650; + Object oldString650 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(650); + if (oldString650 instanceof Utf8) { + charSequence650 = (decoder).readString(((Utf8) oldString650)); + } else { + charSequence650 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(650, charSequence650); + } else { + throw new RuntimeException(("Illegal union index for 'F650': "+ unionIndex650)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema325(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex651 = (decoder.readIndex()); + if (unionIndex651 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(651, null); + } else { + if (unionIndex651 == 1) { + Utf8 charSequence651; + Object oldString651 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(651); + if (oldString651 instanceof Utf8) { + charSequence651 = (decoder).readString(((Utf8) oldString651)); + } else { + charSequence651 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(651, charSequence651); + } else { + throw new RuntimeException(("Illegal union index for 'F651': "+ unionIndex651)); + } + } + int unionIndex652 = (decoder.readIndex()); + if (unionIndex652 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(652, null); + } else { + if (unionIndex652 == 1) { + Utf8 charSequence652; + Object oldString652 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(652); + if (oldString652 instanceof Utf8) { + charSequence652 = (decoder).readString(((Utf8) oldString652)); + } else { + charSequence652 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(652, charSequence652); + } else { + throw new RuntimeException(("Illegal union index for 'F652': "+ unionIndex652)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema326(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex653 = (decoder.readIndex()); + if (unionIndex653 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(653, null); + } else { + if (unionIndex653 == 1) { + Utf8 charSequence653; + Object oldString653 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(653); + if (oldString653 instanceof Utf8) { + charSequence653 = (decoder).readString(((Utf8) oldString653)); + } else { + charSequence653 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(653, charSequence653); + } else { + throw new RuntimeException(("Illegal union index for 'F653': "+ unionIndex653)); + } + } + int unionIndex654 = (decoder.readIndex()); + if (unionIndex654 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(654, null); + } else { + if (unionIndex654 == 1) { + Utf8 charSequence654; + Object oldString654 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(654); + if (oldString654 instanceof Utf8) { + charSequence654 = (decoder).readString(((Utf8) oldString654)); + } else { + charSequence654 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(654, charSequence654); + } else { + throw new RuntimeException(("Illegal union index for 'F654': "+ unionIndex654)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema327(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex655 = (decoder.readIndex()); + if (unionIndex655 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(655, null); + } else { + if (unionIndex655 == 1) { + Utf8 charSequence655; + Object oldString655 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(655); + if (oldString655 instanceof Utf8) { + charSequence655 = (decoder).readString(((Utf8) oldString655)); + } else { + charSequence655 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(655, charSequence655); + } else { + throw new RuntimeException(("Illegal union index for 'F655': "+ unionIndex655)); + } + } + int unionIndex656 = (decoder.readIndex()); + if (unionIndex656 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(656, null); + } else { + if (unionIndex656 == 1) { + Utf8 charSequence656; + Object oldString656 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(656); + if (oldString656 instanceof Utf8) { + charSequence656 = (decoder).readString(((Utf8) oldString656)); + } else { + charSequence656 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(656, charSequence656); + } else { + throw new RuntimeException(("Illegal union index for 'F656': "+ unionIndex656)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema328(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex657 = (decoder.readIndex()); + if (unionIndex657 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(657, null); + } else { + if (unionIndex657 == 1) { + Utf8 charSequence657; + Object oldString657 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(657); + if (oldString657 instanceof Utf8) { + charSequence657 = (decoder).readString(((Utf8) oldString657)); + } else { + charSequence657 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(657, charSequence657); + } else { + throw new RuntimeException(("Illegal union index for 'F657': "+ unionIndex657)); + } + } + int unionIndex658 = (decoder.readIndex()); + if (unionIndex658 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(658, null); + } else { + if (unionIndex658 == 1) { + Utf8 charSequence658; + Object oldString658 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(658); + if (oldString658 instanceof Utf8) { + charSequence658 = (decoder).readString(((Utf8) oldString658)); + } else { + charSequence658 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(658, charSequence658); + } else { + throw new RuntimeException(("Illegal union index for 'F658': "+ unionIndex658)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema329(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex659 = (decoder.readIndex()); + if (unionIndex659 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(659, null); + } else { + if (unionIndex659 == 1) { + Utf8 charSequence659; + Object oldString659 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(659); + if (oldString659 instanceof Utf8) { + charSequence659 = (decoder).readString(((Utf8) oldString659)); + } else { + charSequence659 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(659, charSequence659); + } else { + throw new RuntimeException(("Illegal union index for 'F659': "+ unionIndex659)); + } + } + int unionIndex660 = (decoder.readIndex()); + if (unionIndex660 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(660, null); + } else { + if (unionIndex660 == 1) { + Utf8 charSequence660; + Object oldString660 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(660); + if (oldString660 instanceof Utf8) { + charSequence660 = (decoder).readString(((Utf8) oldString660)); + } else { + charSequence660 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(660, charSequence660); + } else { + throw new RuntimeException(("Illegal union index for 'F660': "+ unionIndex660)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema330(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex661 = (decoder.readIndex()); + if (unionIndex661 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(661, null); + } else { + if (unionIndex661 == 1) { + Utf8 charSequence661; + Object oldString661 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(661); + if (oldString661 instanceof Utf8) { + charSequence661 = (decoder).readString(((Utf8) oldString661)); + } else { + charSequence661 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(661, charSequence661); + } else { + throw new RuntimeException(("Illegal union index for 'F661': "+ unionIndex661)); + } + } + int unionIndex662 = (decoder.readIndex()); + if (unionIndex662 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(662, null); + } else { + if (unionIndex662 == 1) { + Utf8 charSequence662; + Object oldString662 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(662); + if (oldString662 instanceof Utf8) { + charSequence662 = (decoder).readString(((Utf8) oldString662)); + } else { + charSequence662 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(662, charSequence662); + } else { + throw new RuntimeException(("Illegal union index for 'F662': "+ unionIndex662)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema331(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex663 = (decoder.readIndex()); + if (unionIndex663 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(663, null); + } else { + if (unionIndex663 == 1) { + Utf8 charSequence663; + Object oldString663 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(663); + if (oldString663 instanceof Utf8) { + charSequence663 = (decoder).readString(((Utf8) oldString663)); + } else { + charSequence663 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(663, charSequence663); + } else { + throw new RuntimeException(("Illegal union index for 'F663': "+ unionIndex663)); + } + } + int unionIndex664 = (decoder.readIndex()); + if (unionIndex664 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(664, null); + } else { + if (unionIndex664 == 1) { + Utf8 charSequence664; + Object oldString664 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(664); + if (oldString664 instanceof Utf8) { + charSequence664 = (decoder).readString(((Utf8) oldString664)); + } else { + charSequence664 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(664, charSequence664); + } else { + throw new RuntimeException(("Illegal union index for 'F664': "+ unionIndex664)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema332(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex665 = (decoder.readIndex()); + if (unionIndex665 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(665, null); + } else { + if (unionIndex665 == 1) { + Utf8 charSequence665; + Object oldString665 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(665); + if (oldString665 instanceof Utf8) { + charSequence665 = (decoder).readString(((Utf8) oldString665)); + } else { + charSequence665 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(665, charSequence665); + } else { + throw new RuntimeException(("Illegal union index for 'F665': "+ unionIndex665)); + } + } + int unionIndex666 = (decoder.readIndex()); + if (unionIndex666 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(666, null); + } else { + if (unionIndex666 == 1) { + Utf8 charSequence666; + Object oldString666 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(666); + if (oldString666 instanceof Utf8) { + charSequence666 = (decoder).readString(((Utf8) oldString666)); + } else { + charSequence666 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(666, charSequence666); + } else { + throw new RuntimeException(("Illegal union index for 'F666': "+ unionIndex666)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema333(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex667 = (decoder.readIndex()); + if (unionIndex667 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(667, null); + } else { + if (unionIndex667 == 1) { + Utf8 charSequence667; + Object oldString667 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(667); + if (oldString667 instanceof Utf8) { + charSequence667 = (decoder).readString(((Utf8) oldString667)); + } else { + charSequence667 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(667, charSequence667); + } else { + throw new RuntimeException(("Illegal union index for 'F667': "+ unionIndex667)); + } + } + int unionIndex668 = (decoder.readIndex()); + if (unionIndex668 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(668, null); + } else { + if (unionIndex668 == 1) { + Utf8 charSequence668; + Object oldString668 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(668); + if (oldString668 instanceof Utf8) { + charSequence668 = (decoder).readString(((Utf8) oldString668)); + } else { + charSequence668 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(668, charSequence668); + } else { + throw new RuntimeException(("Illegal union index for 'F668': "+ unionIndex668)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema334(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex669 = (decoder.readIndex()); + if (unionIndex669 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(669, null); + } else { + if (unionIndex669 == 1) { + Utf8 charSequence669; + Object oldString669 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(669); + if (oldString669 instanceof Utf8) { + charSequence669 = (decoder).readString(((Utf8) oldString669)); + } else { + charSequence669 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(669, charSequence669); + } else { + throw new RuntimeException(("Illegal union index for 'F669': "+ unionIndex669)); + } + } + int unionIndex670 = (decoder.readIndex()); + if (unionIndex670 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(670, null); + } else { + if (unionIndex670 == 1) { + Utf8 charSequence670; + Object oldString670 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(670); + if (oldString670 instanceof Utf8) { + charSequence670 = (decoder).readString(((Utf8) oldString670)); + } else { + charSequence670 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(670, charSequence670); + } else { + throw new RuntimeException(("Illegal union index for 'F670': "+ unionIndex670)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema335(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex671 = (decoder.readIndex()); + if (unionIndex671 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(671, null); + } else { + if (unionIndex671 == 1) { + Utf8 charSequence671; + Object oldString671 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(671); + if (oldString671 instanceof Utf8) { + charSequence671 = (decoder).readString(((Utf8) oldString671)); + } else { + charSequence671 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(671, charSequence671); + } else { + throw new RuntimeException(("Illegal union index for 'F671': "+ unionIndex671)); + } + } + int unionIndex672 = (decoder.readIndex()); + if (unionIndex672 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(672, null); + } else { + if (unionIndex672 == 1) { + Utf8 charSequence672; + Object oldString672 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(672); + if (oldString672 instanceof Utf8) { + charSequence672 = (decoder).readString(((Utf8) oldString672)); + } else { + charSequence672 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(672, charSequence672); + } else { + throw new RuntimeException(("Illegal union index for 'F672': "+ unionIndex672)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema336(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex673 = (decoder.readIndex()); + if (unionIndex673 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(673, null); + } else { + if (unionIndex673 == 1) { + Utf8 charSequence673; + Object oldString673 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(673); + if (oldString673 instanceof Utf8) { + charSequence673 = (decoder).readString(((Utf8) oldString673)); + } else { + charSequence673 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(673, charSequence673); + } else { + throw new RuntimeException(("Illegal union index for 'F673': "+ unionIndex673)); + } + } + int unionIndex674 = (decoder.readIndex()); + if (unionIndex674 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(674, null); + } else { + if (unionIndex674 == 1) { + Utf8 charSequence674; + Object oldString674 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(674); + if (oldString674 instanceof Utf8) { + charSequence674 = (decoder).readString(((Utf8) oldString674)); + } else { + charSequence674 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(674, charSequence674); + } else { + throw new RuntimeException(("Illegal union index for 'F674': "+ unionIndex674)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema337(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex675 = (decoder.readIndex()); + if (unionIndex675 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(675, null); + } else { + if (unionIndex675 == 1) { + Utf8 charSequence675; + Object oldString675 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(675); + if (oldString675 instanceof Utf8) { + charSequence675 = (decoder).readString(((Utf8) oldString675)); + } else { + charSequence675 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(675, charSequence675); + } else { + throw new RuntimeException(("Illegal union index for 'F675': "+ unionIndex675)); + } + } + int unionIndex676 = (decoder.readIndex()); + if (unionIndex676 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(676, null); + } else { + if (unionIndex676 == 1) { + Utf8 charSequence676; + Object oldString676 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(676); + if (oldString676 instanceof Utf8) { + charSequence676 = (decoder).readString(((Utf8) oldString676)); + } else { + charSequence676 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(676, charSequence676); + } else { + throw new RuntimeException(("Illegal union index for 'F676': "+ unionIndex676)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema338(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex677 = (decoder.readIndex()); + if (unionIndex677 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(677, null); + } else { + if (unionIndex677 == 1) { + Utf8 charSequence677; + Object oldString677 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(677); + if (oldString677 instanceof Utf8) { + charSequence677 = (decoder).readString(((Utf8) oldString677)); + } else { + charSequence677 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(677, charSequence677); + } else { + throw new RuntimeException(("Illegal union index for 'F677': "+ unionIndex677)); + } + } + int unionIndex678 = (decoder.readIndex()); + if (unionIndex678 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(678, null); + } else { + if (unionIndex678 == 1) { + Utf8 charSequence678; + Object oldString678 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(678); + if (oldString678 instanceof Utf8) { + charSequence678 = (decoder).readString(((Utf8) oldString678)); + } else { + charSequence678 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(678, charSequence678); + } else { + throw new RuntimeException(("Illegal union index for 'F678': "+ unionIndex678)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema339(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex679 = (decoder.readIndex()); + if (unionIndex679 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(679, null); + } else { + if (unionIndex679 == 1) { + Utf8 charSequence679; + Object oldString679 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(679); + if (oldString679 instanceof Utf8) { + charSequence679 = (decoder).readString(((Utf8) oldString679)); + } else { + charSequence679 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(679, charSequence679); + } else { + throw new RuntimeException(("Illegal union index for 'F679': "+ unionIndex679)); + } + } + int unionIndex680 = (decoder.readIndex()); + if (unionIndex680 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(680, null); + } else { + if (unionIndex680 == 1) { + Utf8 charSequence680; + Object oldString680 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(680); + if (oldString680 instanceof Utf8) { + charSequence680 = (decoder).readString(((Utf8) oldString680)); + } else { + charSequence680 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(680, charSequence680); + } else { + throw new RuntimeException(("Illegal union index for 'F680': "+ unionIndex680)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema340(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex681 = (decoder.readIndex()); + if (unionIndex681 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(681, null); + } else { + if (unionIndex681 == 1) { + Utf8 charSequence681; + Object oldString681 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(681); + if (oldString681 instanceof Utf8) { + charSequence681 = (decoder).readString(((Utf8) oldString681)); + } else { + charSequence681 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(681, charSequence681); + } else { + throw new RuntimeException(("Illegal union index for 'F681': "+ unionIndex681)); + } + } + int unionIndex682 = (decoder.readIndex()); + if (unionIndex682 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(682, null); + } else { + if (unionIndex682 == 1) { + Utf8 charSequence682; + Object oldString682 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(682); + if (oldString682 instanceof Utf8) { + charSequence682 = (decoder).readString(((Utf8) oldString682)); + } else { + charSequence682 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(682, charSequence682); + } else { + throw new RuntimeException(("Illegal union index for 'F682': "+ unionIndex682)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema341(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex683 = (decoder.readIndex()); + if (unionIndex683 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(683, null); + } else { + if (unionIndex683 == 1) { + Utf8 charSequence683; + Object oldString683 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(683); + if (oldString683 instanceof Utf8) { + charSequence683 = (decoder).readString(((Utf8) oldString683)); + } else { + charSequence683 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(683, charSequence683); + } else { + throw new RuntimeException(("Illegal union index for 'F683': "+ unionIndex683)); + } + } + int unionIndex684 = (decoder.readIndex()); + if (unionIndex684 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(684, null); + } else { + if (unionIndex684 == 1) { + Utf8 charSequence684; + Object oldString684 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(684); + if (oldString684 instanceof Utf8) { + charSequence684 = (decoder).readString(((Utf8) oldString684)); + } else { + charSequence684 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(684, charSequence684); + } else { + throw new RuntimeException(("Illegal union index for 'F684': "+ unionIndex684)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema342(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex685 = (decoder.readIndex()); + if (unionIndex685 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(685, null); + } else { + if (unionIndex685 == 1) { + Utf8 charSequence685; + Object oldString685 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(685); + if (oldString685 instanceof Utf8) { + charSequence685 = (decoder).readString(((Utf8) oldString685)); + } else { + charSequence685 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(685, charSequence685); + } else { + throw new RuntimeException(("Illegal union index for 'F685': "+ unionIndex685)); + } + } + int unionIndex686 = (decoder.readIndex()); + if (unionIndex686 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(686, null); + } else { + if (unionIndex686 == 1) { + Utf8 charSequence686; + Object oldString686 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(686); + if (oldString686 instanceof Utf8) { + charSequence686 = (decoder).readString(((Utf8) oldString686)); + } else { + charSequence686 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(686, charSequence686); + } else { + throw new RuntimeException(("Illegal union index for 'F686': "+ unionIndex686)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema343(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex687 = (decoder.readIndex()); + if (unionIndex687 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(687, null); + } else { + if (unionIndex687 == 1) { + Utf8 charSequence687; + Object oldString687 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(687); + if (oldString687 instanceof Utf8) { + charSequence687 = (decoder).readString(((Utf8) oldString687)); + } else { + charSequence687 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(687, charSequence687); + } else { + throw new RuntimeException(("Illegal union index for 'F687': "+ unionIndex687)); + } + } + int unionIndex688 = (decoder.readIndex()); + if (unionIndex688 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(688, null); + } else { + if (unionIndex688 == 1) { + Utf8 charSequence688; + Object oldString688 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(688); + if (oldString688 instanceof Utf8) { + charSequence688 = (decoder).readString(((Utf8) oldString688)); + } else { + charSequence688 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(688, charSequence688); + } else { + throw new RuntimeException(("Illegal union index for 'F688': "+ unionIndex688)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema344(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex689 = (decoder.readIndex()); + if (unionIndex689 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(689, null); + } else { + if (unionIndex689 == 1) { + Utf8 charSequence689; + Object oldString689 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(689); + if (oldString689 instanceof Utf8) { + charSequence689 = (decoder).readString(((Utf8) oldString689)); + } else { + charSequence689 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(689, charSequence689); + } else { + throw new RuntimeException(("Illegal union index for 'F689': "+ unionIndex689)); + } + } + int unionIndex690 = (decoder.readIndex()); + if (unionIndex690 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(690, null); + } else { + if (unionIndex690 == 1) { + Utf8 charSequence690; + Object oldString690 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(690); + if (oldString690 instanceof Utf8) { + charSequence690 = (decoder).readString(((Utf8) oldString690)); + } else { + charSequence690 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(690, charSequence690); + } else { + throw new RuntimeException(("Illegal union index for 'F690': "+ unionIndex690)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema345(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex691 = (decoder.readIndex()); + if (unionIndex691 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(691, null); + } else { + if (unionIndex691 == 1) { + Utf8 charSequence691; + Object oldString691 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(691); + if (oldString691 instanceof Utf8) { + charSequence691 = (decoder).readString(((Utf8) oldString691)); + } else { + charSequence691 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(691, charSequence691); + } else { + throw new RuntimeException(("Illegal union index for 'F691': "+ unionIndex691)); + } + } + int unionIndex692 = (decoder.readIndex()); + if (unionIndex692 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(692, null); + } else { + if (unionIndex692 == 1) { + Utf8 charSequence692; + Object oldString692 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(692); + if (oldString692 instanceof Utf8) { + charSequence692 = (decoder).readString(((Utf8) oldString692)); + } else { + charSequence692 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(692, charSequence692); + } else { + throw new RuntimeException(("Illegal union index for 'F692': "+ unionIndex692)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema346(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex693 = (decoder.readIndex()); + if (unionIndex693 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(693, null); + } else { + if (unionIndex693 == 1) { + Utf8 charSequence693; + Object oldString693 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(693); + if (oldString693 instanceof Utf8) { + charSequence693 = (decoder).readString(((Utf8) oldString693)); + } else { + charSequence693 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(693, charSequence693); + } else { + throw new RuntimeException(("Illegal union index for 'F693': "+ unionIndex693)); + } + } + int unionIndex694 = (decoder.readIndex()); + if (unionIndex694 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(694, null); + } else { + if (unionIndex694 == 1) { + Utf8 charSequence694; + Object oldString694 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(694); + if (oldString694 instanceof Utf8) { + charSequence694 = (decoder).readString(((Utf8) oldString694)); + } else { + charSequence694 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(694, charSequence694); + } else { + throw new RuntimeException(("Illegal union index for 'F694': "+ unionIndex694)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema347(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex695 = (decoder.readIndex()); + if (unionIndex695 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(695, null); + } else { + if (unionIndex695 == 1) { + Utf8 charSequence695; + Object oldString695 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(695); + if (oldString695 instanceof Utf8) { + charSequence695 = (decoder).readString(((Utf8) oldString695)); + } else { + charSequence695 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(695, charSequence695); + } else { + throw new RuntimeException(("Illegal union index for 'F695': "+ unionIndex695)); + } + } + int unionIndex696 = (decoder.readIndex()); + if (unionIndex696 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(696, null); + } else { + if (unionIndex696 == 1) { + Utf8 charSequence696; + Object oldString696 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(696); + if (oldString696 instanceof Utf8) { + charSequence696 = (decoder).readString(((Utf8) oldString696)); + } else { + charSequence696 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(696, charSequence696); + } else { + throw new RuntimeException(("Illegal union index for 'F696': "+ unionIndex696)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema348(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex697 = (decoder.readIndex()); + if (unionIndex697 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(697, null); + } else { + if (unionIndex697 == 1) { + Utf8 charSequence697; + Object oldString697 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(697); + if (oldString697 instanceof Utf8) { + charSequence697 = (decoder).readString(((Utf8) oldString697)); + } else { + charSequence697 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(697, charSequence697); + } else { + throw new RuntimeException(("Illegal union index for 'F697': "+ unionIndex697)); + } + } + int unionIndex698 = (decoder.readIndex()); + if (unionIndex698 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(698, null); + } else { + if (unionIndex698 == 1) { + Utf8 charSequence698; + Object oldString698 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(698); + if (oldString698 instanceof Utf8) { + charSequence698 = (decoder).readString(((Utf8) oldString698)); + } else { + charSequence698 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(698, charSequence698); + } else { + throw new RuntimeException(("Illegal union index for 'F698': "+ unionIndex698)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema349(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex699 = (decoder.readIndex()); + if (unionIndex699 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(699, null); + } else { + if (unionIndex699 == 1) { + Utf8 charSequence699; + Object oldString699 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(699); + if (oldString699 instanceof Utf8) { + charSequence699 = (decoder).readString(((Utf8) oldString699)); + } else { + charSequence699 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(699, charSequence699); + } else { + throw new RuntimeException(("Illegal union index for 'F699': "+ unionIndex699)); + } + } + int unionIndex700 = (decoder.readIndex()); + if (unionIndex700 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(700, null); + } else { + if (unionIndex700 == 1) { + Utf8 charSequence700; + Object oldString700 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(700); + if (oldString700 instanceof Utf8) { + charSequence700 = (decoder).readString(((Utf8) oldString700)); + } else { + charSequence700 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(700, charSequence700); + } else { + throw new RuntimeException(("Illegal union index for 'F700': "+ unionIndex700)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema350(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex701 = (decoder.readIndex()); + if (unionIndex701 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(701, null); + } else { + if (unionIndex701 == 1) { + Utf8 charSequence701; + Object oldString701 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(701); + if (oldString701 instanceof Utf8) { + charSequence701 = (decoder).readString(((Utf8) oldString701)); + } else { + charSequence701 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(701, charSequence701); + } else { + throw new RuntimeException(("Illegal union index for 'F701': "+ unionIndex701)); + } + } + int unionIndex702 = (decoder.readIndex()); + if (unionIndex702 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(702, null); + } else { + if (unionIndex702 == 1) { + Utf8 charSequence702; + Object oldString702 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(702); + if (oldString702 instanceof Utf8) { + charSequence702 = (decoder).readString(((Utf8) oldString702)); + } else { + charSequence702 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(702, charSequence702); + } else { + throw new RuntimeException(("Illegal union index for 'F702': "+ unionIndex702)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema351(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex703 = (decoder.readIndex()); + if (unionIndex703 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(703, null); + } else { + if (unionIndex703 == 1) { + Utf8 charSequence703; + Object oldString703 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(703); + if (oldString703 instanceof Utf8) { + charSequence703 = (decoder).readString(((Utf8) oldString703)); + } else { + charSequence703 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(703, charSequence703); + } else { + throw new RuntimeException(("Illegal union index for 'F703': "+ unionIndex703)); + } + } + int unionIndex704 = (decoder.readIndex()); + if (unionIndex704 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(704, null); + } else { + if (unionIndex704 == 1) { + Utf8 charSequence704; + Object oldString704 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(704); + if (oldString704 instanceof Utf8) { + charSequence704 = (decoder).readString(((Utf8) oldString704)); + } else { + charSequence704 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(704, charSequence704); + } else { + throw new RuntimeException(("Illegal union index for 'F704': "+ unionIndex704)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema352(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex705 = (decoder.readIndex()); + if (unionIndex705 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(705, null); + } else { + if (unionIndex705 == 1) { + Utf8 charSequence705; + Object oldString705 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(705); + if (oldString705 instanceof Utf8) { + charSequence705 = (decoder).readString(((Utf8) oldString705)); + } else { + charSequence705 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(705, charSequence705); + } else { + throw new RuntimeException(("Illegal union index for 'F705': "+ unionIndex705)); + } + } + int unionIndex706 = (decoder.readIndex()); + if (unionIndex706 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(706, null); + } else { + if (unionIndex706 == 1) { + Utf8 charSequence706; + Object oldString706 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(706); + if (oldString706 instanceof Utf8) { + charSequence706 = (decoder).readString(((Utf8) oldString706)); + } else { + charSequence706 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(706, charSequence706); + } else { + throw new RuntimeException(("Illegal union index for 'F706': "+ unionIndex706)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema353(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex707 = (decoder.readIndex()); + if (unionIndex707 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(707, null); + } else { + if (unionIndex707 == 1) { + Utf8 charSequence707; + Object oldString707 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(707); + if (oldString707 instanceof Utf8) { + charSequence707 = (decoder).readString(((Utf8) oldString707)); + } else { + charSequence707 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(707, charSequence707); + } else { + throw new RuntimeException(("Illegal union index for 'F707': "+ unionIndex707)); + } + } + int unionIndex708 = (decoder.readIndex()); + if (unionIndex708 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(708, null); + } else { + if (unionIndex708 == 1) { + Utf8 charSequence708; + Object oldString708 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(708); + if (oldString708 instanceof Utf8) { + charSequence708 = (decoder).readString(((Utf8) oldString708)); + } else { + charSequence708 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(708, charSequence708); + } else { + throw new RuntimeException(("Illegal union index for 'F708': "+ unionIndex708)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema354(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex709 = (decoder.readIndex()); + if (unionIndex709 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(709, null); + } else { + if (unionIndex709 == 1) { + Utf8 charSequence709; + Object oldString709 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(709); + if (oldString709 instanceof Utf8) { + charSequence709 = (decoder).readString(((Utf8) oldString709)); + } else { + charSequence709 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(709, charSequence709); + } else { + throw new RuntimeException(("Illegal union index for 'F709': "+ unionIndex709)); + } + } + int unionIndex710 = (decoder.readIndex()); + if (unionIndex710 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(710, null); + } else { + if (unionIndex710 == 1) { + Utf8 charSequence710; + Object oldString710 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(710); + if (oldString710 instanceof Utf8) { + charSequence710 = (decoder).readString(((Utf8) oldString710)); + } else { + charSequence710 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(710, charSequence710); + } else { + throw new RuntimeException(("Illegal union index for 'F710': "+ unionIndex710)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema355(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex711 = (decoder.readIndex()); + if (unionIndex711 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(711, null); + } else { + if (unionIndex711 == 1) { + Utf8 charSequence711; + Object oldString711 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(711); + if (oldString711 instanceof Utf8) { + charSequence711 = (decoder).readString(((Utf8) oldString711)); + } else { + charSequence711 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(711, charSequence711); + } else { + throw new RuntimeException(("Illegal union index for 'F711': "+ unionIndex711)); + } + } + int unionIndex712 = (decoder.readIndex()); + if (unionIndex712 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(712, null); + } else { + if (unionIndex712 == 1) { + Utf8 charSequence712; + Object oldString712 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(712); + if (oldString712 instanceof Utf8) { + charSequence712 = (decoder).readString(((Utf8) oldString712)); + } else { + charSequence712 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(712, charSequence712); + } else { + throw new RuntimeException(("Illegal union index for 'F712': "+ unionIndex712)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema356(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex713 = (decoder.readIndex()); + if (unionIndex713 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(713, null); + } else { + if (unionIndex713 == 1) { + Utf8 charSequence713; + Object oldString713 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(713); + if (oldString713 instanceof Utf8) { + charSequence713 = (decoder).readString(((Utf8) oldString713)); + } else { + charSequence713 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(713, charSequence713); + } else { + throw new RuntimeException(("Illegal union index for 'F713': "+ unionIndex713)); + } + } + int unionIndex714 = (decoder.readIndex()); + if (unionIndex714 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(714, null); + } else { + if (unionIndex714 == 1) { + Utf8 charSequence714; + Object oldString714 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(714); + if (oldString714 instanceof Utf8) { + charSequence714 = (decoder).readString(((Utf8) oldString714)); + } else { + charSequence714 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(714, charSequence714); + } else { + throw new RuntimeException(("Illegal union index for 'F714': "+ unionIndex714)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema357(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex715 = (decoder.readIndex()); + if (unionIndex715 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(715, null); + } else { + if (unionIndex715 == 1) { + Utf8 charSequence715; + Object oldString715 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(715); + if (oldString715 instanceof Utf8) { + charSequence715 = (decoder).readString(((Utf8) oldString715)); + } else { + charSequence715 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(715, charSequence715); + } else { + throw new RuntimeException(("Illegal union index for 'F715': "+ unionIndex715)); + } + } + int unionIndex716 = (decoder.readIndex()); + if (unionIndex716 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(716, null); + } else { + if (unionIndex716 == 1) { + Utf8 charSequence716; + Object oldString716 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(716); + if (oldString716 instanceof Utf8) { + charSequence716 = (decoder).readString(((Utf8) oldString716)); + } else { + charSequence716 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(716, charSequence716); + } else { + throw new RuntimeException(("Illegal union index for 'F716': "+ unionIndex716)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema358(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex717 = (decoder.readIndex()); + if (unionIndex717 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(717, null); + } else { + if (unionIndex717 == 1) { + Utf8 charSequence717; + Object oldString717 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(717); + if (oldString717 instanceof Utf8) { + charSequence717 = (decoder).readString(((Utf8) oldString717)); + } else { + charSequence717 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(717, charSequence717); + } else { + throw new RuntimeException(("Illegal union index for 'F717': "+ unionIndex717)); + } + } + int unionIndex718 = (decoder.readIndex()); + if (unionIndex718 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(718, null); + } else { + if (unionIndex718 == 1) { + Utf8 charSequence718; + Object oldString718 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(718); + if (oldString718 instanceof Utf8) { + charSequence718 = (decoder).readString(((Utf8) oldString718)); + } else { + charSequence718 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(718, charSequence718); + } else { + throw new RuntimeException(("Illegal union index for 'F718': "+ unionIndex718)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema359(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex719 = (decoder.readIndex()); + if (unionIndex719 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(719, null); + } else { + if (unionIndex719 == 1) { + Utf8 charSequence719; + Object oldString719 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(719); + if (oldString719 instanceof Utf8) { + charSequence719 = (decoder).readString(((Utf8) oldString719)); + } else { + charSequence719 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(719, charSequence719); + } else { + throw new RuntimeException(("Illegal union index for 'F719': "+ unionIndex719)); + } + } + int unionIndex720 = (decoder.readIndex()); + if (unionIndex720 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(720, null); + } else { + if (unionIndex720 == 1) { + Utf8 charSequence720; + Object oldString720 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(720); + if (oldString720 instanceof Utf8) { + charSequence720 = (decoder).readString(((Utf8) oldString720)); + } else { + charSequence720 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(720, charSequence720); + } else { + throw new RuntimeException(("Illegal union index for 'F720': "+ unionIndex720)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema360(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex721 = (decoder.readIndex()); + if (unionIndex721 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(721, null); + } else { + if (unionIndex721 == 1) { + Utf8 charSequence721; + Object oldString721 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(721); + if (oldString721 instanceof Utf8) { + charSequence721 = (decoder).readString(((Utf8) oldString721)); + } else { + charSequence721 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(721, charSequence721); + } else { + throw new RuntimeException(("Illegal union index for 'F721': "+ unionIndex721)); + } + } + int unionIndex722 = (decoder.readIndex()); + if (unionIndex722 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(722, null); + } else { + if (unionIndex722 == 1) { + Utf8 charSequence722; + Object oldString722 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(722); + if (oldString722 instanceof Utf8) { + charSequence722 = (decoder).readString(((Utf8) oldString722)); + } else { + charSequence722 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(722, charSequence722); + } else { + throw new RuntimeException(("Illegal union index for 'F722': "+ unionIndex722)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema361(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex723 = (decoder.readIndex()); + if (unionIndex723 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(723, null); + } else { + if (unionIndex723 == 1) { + Utf8 charSequence723; + Object oldString723 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(723); + if (oldString723 instanceof Utf8) { + charSequence723 = (decoder).readString(((Utf8) oldString723)); + } else { + charSequence723 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(723, charSequence723); + } else { + throw new RuntimeException(("Illegal union index for 'F723': "+ unionIndex723)); + } + } + int unionIndex724 = (decoder.readIndex()); + if (unionIndex724 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(724, null); + } else { + if (unionIndex724 == 1) { + Utf8 charSequence724; + Object oldString724 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(724); + if (oldString724 instanceof Utf8) { + charSequence724 = (decoder).readString(((Utf8) oldString724)); + } else { + charSequence724 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(724, charSequence724); + } else { + throw new RuntimeException(("Illegal union index for 'F724': "+ unionIndex724)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema362(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex725 = (decoder.readIndex()); + if (unionIndex725 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(725, null); + } else { + if (unionIndex725 == 1) { + Utf8 charSequence725; + Object oldString725 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(725); + if (oldString725 instanceof Utf8) { + charSequence725 = (decoder).readString(((Utf8) oldString725)); + } else { + charSequence725 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(725, charSequence725); + } else { + throw new RuntimeException(("Illegal union index for 'F725': "+ unionIndex725)); + } + } + int unionIndex726 = (decoder.readIndex()); + if (unionIndex726 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(726, null); + } else { + if (unionIndex726 == 1) { + Utf8 charSequence726; + Object oldString726 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(726); + if (oldString726 instanceof Utf8) { + charSequence726 = (decoder).readString(((Utf8) oldString726)); + } else { + charSequence726 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(726, charSequence726); + } else { + throw new RuntimeException(("Illegal union index for 'F726': "+ unionIndex726)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema363(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex727 = (decoder.readIndex()); + if (unionIndex727 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(727, null); + } else { + if (unionIndex727 == 1) { + Utf8 charSequence727; + Object oldString727 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(727); + if (oldString727 instanceof Utf8) { + charSequence727 = (decoder).readString(((Utf8) oldString727)); + } else { + charSequence727 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(727, charSequence727); + } else { + throw new RuntimeException(("Illegal union index for 'F727': "+ unionIndex727)); + } + } + int unionIndex728 = (decoder.readIndex()); + if (unionIndex728 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(728, null); + } else { + if (unionIndex728 == 1) { + Utf8 charSequence728; + Object oldString728 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(728); + if (oldString728 instanceof Utf8) { + charSequence728 = (decoder).readString(((Utf8) oldString728)); + } else { + charSequence728 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(728, charSequence728); + } else { + throw new RuntimeException(("Illegal union index for 'F728': "+ unionIndex728)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema364(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex729 = (decoder.readIndex()); + if (unionIndex729 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(729, null); + } else { + if (unionIndex729 == 1) { + Utf8 charSequence729; + Object oldString729 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(729); + if (oldString729 instanceof Utf8) { + charSequence729 = (decoder).readString(((Utf8) oldString729)); + } else { + charSequence729 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(729, charSequence729); + } else { + throw new RuntimeException(("Illegal union index for 'F729': "+ unionIndex729)); + } + } + int unionIndex730 = (decoder.readIndex()); + if (unionIndex730 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(730, null); + } else { + if (unionIndex730 == 1) { + Utf8 charSequence730; + Object oldString730 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(730); + if (oldString730 instanceof Utf8) { + charSequence730 = (decoder).readString(((Utf8) oldString730)); + } else { + charSequence730 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(730, charSequence730); + } else { + throw new RuntimeException(("Illegal union index for 'F730': "+ unionIndex730)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema365(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex731 = (decoder.readIndex()); + if (unionIndex731 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(731, null); + } else { + if (unionIndex731 == 1) { + Utf8 charSequence731; + Object oldString731 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(731); + if (oldString731 instanceof Utf8) { + charSequence731 = (decoder).readString(((Utf8) oldString731)); + } else { + charSequence731 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(731, charSequence731); + } else { + throw new RuntimeException(("Illegal union index for 'F731': "+ unionIndex731)); + } + } + int unionIndex732 = (decoder.readIndex()); + if (unionIndex732 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(732, null); + } else { + if (unionIndex732 == 1) { + Utf8 charSequence732; + Object oldString732 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(732); + if (oldString732 instanceof Utf8) { + charSequence732 = (decoder).readString(((Utf8) oldString732)); + } else { + charSequence732 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(732, charSequence732); + } else { + throw new RuntimeException(("Illegal union index for 'F732': "+ unionIndex732)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema366(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex733 = (decoder.readIndex()); + if (unionIndex733 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(733, null); + } else { + if (unionIndex733 == 1) { + Utf8 charSequence733; + Object oldString733 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(733); + if (oldString733 instanceof Utf8) { + charSequence733 = (decoder).readString(((Utf8) oldString733)); + } else { + charSequence733 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(733, charSequence733); + } else { + throw new RuntimeException(("Illegal union index for 'F733': "+ unionIndex733)); + } + } + int unionIndex734 = (decoder.readIndex()); + if (unionIndex734 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(734, null); + } else { + if (unionIndex734 == 1) { + Utf8 charSequence734; + Object oldString734 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(734); + if (oldString734 instanceof Utf8) { + charSequence734 = (decoder).readString(((Utf8) oldString734)); + } else { + charSequence734 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(734, charSequence734); + } else { + throw new RuntimeException(("Illegal union index for 'F734': "+ unionIndex734)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema367(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex735 = (decoder.readIndex()); + if (unionIndex735 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(735, null); + } else { + if (unionIndex735 == 1) { + Utf8 charSequence735; + Object oldString735 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(735); + if (oldString735 instanceof Utf8) { + charSequence735 = (decoder).readString(((Utf8) oldString735)); + } else { + charSequence735 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(735, charSequence735); + } else { + throw new RuntimeException(("Illegal union index for 'F735': "+ unionIndex735)); + } + } + int unionIndex736 = (decoder.readIndex()); + if (unionIndex736 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(736, null); + } else { + if (unionIndex736 == 1) { + Utf8 charSequence736; + Object oldString736 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(736); + if (oldString736 instanceof Utf8) { + charSequence736 = (decoder).readString(((Utf8) oldString736)); + } else { + charSequence736 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(736, charSequence736); + } else { + throw new RuntimeException(("Illegal union index for 'F736': "+ unionIndex736)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema368(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex737 = (decoder.readIndex()); + if (unionIndex737 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(737, null); + } else { + if (unionIndex737 == 1) { + Utf8 charSequence737; + Object oldString737 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(737); + if (oldString737 instanceof Utf8) { + charSequence737 = (decoder).readString(((Utf8) oldString737)); + } else { + charSequence737 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(737, charSequence737); + } else { + throw new RuntimeException(("Illegal union index for 'F737': "+ unionIndex737)); + } + } + int unionIndex738 = (decoder.readIndex()); + if (unionIndex738 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(738, null); + } else { + if (unionIndex738 == 1) { + Utf8 charSequence738; + Object oldString738 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(738); + if (oldString738 instanceof Utf8) { + charSequence738 = (decoder).readString(((Utf8) oldString738)); + } else { + charSequence738 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(738, charSequence738); + } else { + throw new RuntimeException(("Illegal union index for 'F738': "+ unionIndex738)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema369(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex739 = (decoder.readIndex()); + if (unionIndex739 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(739, null); + } else { + if (unionIndex739 == 1) { + Utf8 charSequence739; + Object oldString739 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(739); + if (oldString739 instanceof Utf8) { + charSequence739 = (decoder).readString(((Utf8) oldString739)); + } else { + charSequence739 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(739, charSequence739); + } else { + throw new RuntimeException(("Illegal union index for 'F739': "+ unionIndex739)); + } + } + int unionIndex740 = (decoder.readIndex()); + if (unionIndex740 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(740, null); + } else { + if (unionIndex740 == 1) { + Utf8 charSequence740; + Object oldString740 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(740); + if (oldString740 instanceof Utf8) { + charSequence740 = (decoder).readString(((Utf8) oldString740)); + } else { + charSequence740 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(740, charSequence740); + } else { + throw new RuntimeException(("Illegal union index for 'F740': "+ unionIndex740)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema370(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex741 = (decoder.readIndex()); + if (unionIndex741 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(741, null); + } else { + if (unionIndex741 == 1) { + Utf8 charSequence741; + Object oldString741 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(741); + if (oldString741 instanceof Utf8) { + charSequence741 = (decoder).readString(((Utf8) oldString741)); + } else { + charSequence741 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(741, charSequence741); + } else { + throw new RuntimeException(("Illegal union index for 'F741': "+ unionIndex741)); + } + } + int unionIndex742 = (decoder.readIndex()); + if (unionIndex742 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(742, null); + } else { + if (unionIndex742 == 1) { + Utf8 charSequence742; + Object oldString742 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(742); + if (oldString742 instanceof Utf8) { + charSequence742 = (decoder).readString(((Utf8) oldString742)); + } else { + charSequence742 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(742, charSequence742); + } else { + throw new RuntimeException(("Illegal union index for 'F742': "+ unionIndex742)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema371(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex743 = (decoder.readIndex()); + if (unionIndex743 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(743, null); + } else { + if (unionIndex743 == 1) { + Utf8 charSequence743; + Object oldString743 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(743); + if (oldString743 instanceof Utf8) { + charSequence743 = (decoder).readString(((Utf8) oldString743)); + } else { + charSequence743 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(743, charSequence743); + } else { + throw new RuntimeException(("Illegal union index for 'F743': "+ unionIndex743)); + } + } + int unionIndex744 = (decoder.readIndex()); + if (unionIndex744 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(744, null); + } else { + if (unionIndex744 == 1) { + Utf8 charSequence744; + Object oldString744 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(744); + if (oldString744 instanceof Utf8) { + charSequence744 = (decoder).readString(((Utf8) oldString744)); + } else { + charSequence744 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(744, charSequence744); + } else { + throw new RuntimeException(("Illegal union index for 'F744': "+ unionIndex744)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema372(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex745 = (decoder.readIndex()); + if (unionIndex745 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(745, null); + } else { + if (unionIndex745 == 1) { + Utf8 charSequence745; + Object oldString745 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(745); + if (oldString745 instanceof Utf8) { + charSequence745 = (decoder).readString(((Utf8) oldString745)); + } else { + charSequence745 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(745, charSequence745); + } else { + throw new RuntimeException(("Illegal union index for 'F745': "+ unionIndex745)); + } + } + int unionIndex746 = (decoder.readIndex()); + if (unionIndex746 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(746, null); + } else { + if (unionIndex746 == 1) { + Utf8 charSequence746; + Object oldString746 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(746); + if (oldString746 instanceof Utf8) { + charSequence746 = (decoder).readString(((Utf8) oldString746)); + } else { + charSequence746 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(746, charSequence746); + } else { + throw new RuntimeException(("Illegal union index for 'F746': "+ unionIndex746)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema373(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex747 = (decoder.readIndex()); + if (unionIndex747 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(747, null); + } else { + if (unionIndex747 == 1) { + Utf8 charSequence747; + Object oldString747 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(747); + if (oldString747 instanceof Utf8) { + charSequence747 = (decoder).readString(((Utf8) oldString747)); + } else { + charSequence747 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(747, charSequence747); + } else { + throw new RuntimeException(("Illegal union index for 'F747': "+ unionIndex747)); + } + } + int unionIndex748 = (decoder.readIndex()); + if (unionIndex748 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(748, null); + } else { + if (unionIndex748 == 1) { + Utf8 charSequence748; + Object oldString748 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(748); + if (oldString748 instanceof Utf8) { + charSequence748 = (decoder).readString(((Utf8) oldString748)); + } else { + charSequence748 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(748, charSequence748); + } else { + throw new RuntimeException(("Illegal union index for 'F748': "+ unionIndex748)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema374(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex749 = (decoder.readIndex()); + if (unionIndex749 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(749, null); + } else { + if (unionIndex749 == 1) { + Utf8 charSequence749; + Object oldString749 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(749); + if (oldString749 instanceof Utf8) { + charSequence749 = (decoder).readString(((Utf8) oldString749)); + } else { + charSequence749 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(749, charSequence749); + } else { + throw new RuntimeException(("Illegal union index for 'F749': "+ unionIndex749)); + } + } + int unionIndex750 = (decoder.readIndex()); + if (unionIndex750 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(750, null); + } else { + if (unionIndex750 == 1) { + Utf8 charSequence750; + Object oldString750 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(750); + if (oldString750 instanceof Utf8) { + charSequence750 = (decoder).readString(((Utf8) oldString750)); + } else { + charSequence750 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(750, charSequence750); + } else { + throw new RuntimeException(("Illegal union index for 'F750': "+ unionIndex750)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema375(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex751 = (decoder.readIndex()); + if (unionIndex751 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(751, null); + } else { + if (unionIndex751 == 1) { + Utf8 charSequence751; + Object oldString751 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(751); + if (oldString751 instanceof Utf8) { + charSequence751 = (decoder).readString(((Utf8) oldString751)); + } else { + charSequence751 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(751, charSequence751); + } else { + throw new RuntimeException(("Illegal union index for 'F751': "+ unionIndex751)); + } + } + int unionIndex752 = (decoder.readIndex()); + if (unionIndex752 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(752, null); + } else { + if (unionIndex752 == 1) { + Utf8 charSequence752; + Object oldString752 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(752); + if (oldString752 instanceof Utf8) { + charSequence752 = (decoder).readString(((Utf8) oldString752)); + } else { + charSequence752 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(752, charSequence752); + } else { + throw new RuntimeException(("Illegal union index for 'F752': "+ unionIndex752)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema376(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex753 = (decoder.readIndex()); + if (unionIndex753 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(753, null); + } else { + if (unionIndex753 == 1) { + Utf8 charSequence753; + Object oldString753 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(753); + if (oldString753 instanceof Utf8) { + charSequence753 = (decoder).readString(((Utf8) oldString753)); + } else { + charSequence753 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(753, charSequence753); + } else { + throw new RuntimeException(("Illegal union index for 'F753': "+ unionIndex753)); + } + } + int unionIndex754 = (decoder.readIndex()); + if (unionIndex754 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(754, null); + } else { + if (unionIndex754 == 1) { + Utf8 charSequence754; + Object oldString754 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(754); + if (oldString754 instanceof Utf8) { + charSequence754 = (decoder).readString(((Utf8) oldString754)); + } else { + charSequence754 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(754, charSequence754); + } else { + throw new RuntimeException(("Illegal union index for 'F754': "+ unionIndex754)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema377(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex755 = (decoder.readIndex()); + if (unionIndex755 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(755, null); + } else { + if (unionIndex755 == 1) { + Utf8 charSequence755; + Object oldString755 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(755); + if (oldString755 instanceof Utf8) { + charSequence755 = (decoder).readString(((Utf8) oldString755)); + } else { + charSequence755 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(755, charSequence755); + } else { + throw new RuntimeException(("Illegal union index for 'F755': "+ unionIndex755)); + } + } + int unionIndex756 = (decoder.readIndex()); + if (unionIndex756 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(756, null); + } else { + if (unionIndex756 == 1) { + Utf8 charSequence756; + Object oldString756 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(756); + if (oldString756 instanceof Utf8) { + charSequence756 = (decoder).readString(((Utf8) oldString756)); + } else { + charSequence756 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(756, charSequence756); + } else { + throw new RuntimeException(("Illegal union index for 'F756': "+ unionIndex756)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema378(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex757 = (decoder.readIndex()); + if (unionIndex757 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(757, null); + } else { + if (unionIndex757 == 1) { + Utf8 charSequence757; + Object oldString757 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(757); + if (oldString757 instanceof Utf8) { + charSequence757 = (decoder).readString(((Utf8) oldString757)); + } else { + charSequence757 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(757, charSequence757); + } else { + throw new RuntimeException(("Illegal union index for 'F757': "+ unionIndex757)); + } + } + int unionIndex758 = (decoder.readIndex()); + if (unionIndex758 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(758, null); + } else { + if (unionIndex758 == 1) { + Utf8 charSequence758; + Object oldString758 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(758); + if (oldString758 instanceof Utf8) { + charSequence758 = (decoder).readString(((Utf8) oldString758)); + } else { + charSequence758 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(758, charSequence758); + } else { + throw new RuntimeException(("Illegal union index for 'F758': "+ unionIndex758)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema379(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex759 = (decoder.readIndex()); + if (unionIndex759 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(759, null); + } else { + if (unionIndex759 == 1) { + Utf8 charSequence759; + Object oldString759 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(759); + if (oldString759 instanceof Utf8) { + charSequence759 = (decoder).readString(((Utf8) oldString759)); + } else { + charSequence759 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(759, charSequence759); + } else { + throw new RuntimeException(("Illegal union index for 'F759': "+ unionIndex759)); + } + } + int unionIndex760 = (decoder.readIndex()); + if (unionIndex760 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(760, null); + } else { + if (unionIndex760 == 1) { + Utf8 charSequence760; + Object oldString760 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(760); + if (oldString760 instanceof Utf8) { + charSequence760 = (decoder).readString(((Utf8) oldString760)); + } else { + charSequence760 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(760, charSequence760); + } else { + throw new RuntimeException(("Illegal union index for 'F760': "+ unionIndex760)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema380(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex761 = (decoder.readIndex()); + if (unionIndex761 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(761, null); + } else { + if (unionIndex761 == 1) { + Utf8 charSequence761; + Object oldString761 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(761); + if (oldString761 instanceof Utf8) { + charSequence761 = (decoder).readString(((Utf8) oldString761)); + } else { + charSequence761 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(761, charSequence761); + } else { + throw new RuntimeException(("Illegal union index for 'F761': "+ unionIndex761)); + } + } + int unionIndex762 = (decoder.readIndex()); + if (unionIndex762 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(762, null); + } else { + if (unionIndex762 == 1) { + Utf8 charSequence762; + Object oldString762 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(762); + if (oldString762 instanceof Utf8) { + charSequence762 = (decoder).readString(((Utf8) oldString762)); + } else { + charSequence762 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(762, charSequence762); + } else { + throw new RuntimeException(("Illegal union index for 'F762': "+ unionIndex762)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema381(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex763 = (decoder.readIndex()); + if (unionIndex763 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(763, null); + } else { + if (unionIndex763 == 1) { + Utf8 charSequence763; + Object oldString763 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(763); + if (oldString763 instanceof Utf8) { + charSequence763 = (decoder).readString(((Utf8) oldString763)); + } else { + charSequence763 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(763, charSequence763); + } else { + throw new RuntimeException(("Illegal union index for 'F763': "+ unionIndex763)); + } + } + int unionIndex764 = (decoder.readIndex()); + if (unionIndex764 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(764, null); + } else { + if (unionIndex764 == 1) { + Utf8 charSequence764; + Object oldString764 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(764); + if (oldString764 instanceof Utf8) { + charSequence764 = (decoder).readString(((Utf8) oldString764)); + } else { + charSequence764 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(764, charSequence764); + } else { + throw new RuntimeException(("Illegal union index for 'F764': "+ unionIndex764)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema382(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex765 = (decoder.readIndex()); + if (unionIndex765 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(765, null); + } else { + if (unionIndex765 == 1) { + Utf8 charSequence765; + Object oldString765 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(765); + if (oldString765 instanceof Utf8) { + charSequence765 = (decoder).readString(((Utf8) oldString765)); + } else { + charSequence765 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(765, charSequence765); + } else { + throw new RuntimeException(("Illegal union index for 'F765': "+ unionIndex765)); + } + } + int unionIndex766 = (decoder.readIndex()); + if (unionIndex766 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(766, null); + } else { + if (unionIndex766 == 1) { + Utf8 charSequence766; + Object oldString766 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(766); + if (oldString766 instanceof Utf8) { + charSequence766 = (decoder).readString(((Utf8) oldString766)); + } else { + charSequence766 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(766, charSequence766); + } else { + throw new RuntimeException(("Illegal union index for 'F766': "+ unionIndex766)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema383(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex767 = (decoder.readIndex()); + if (unionIndex767 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(767, null); + } else { + if (unionIndex767 == 1) { + Utf8 charSequence767; + Object oldString767 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(767); + if (oldString767 instanceof Utf8) { + charSequence767 = (decoder).readString(((Utf8) oldString767)); + } else { + charSequence767 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(767, charSequence767); + } else { + throw new RuntimeException(("Illegal union index for 'F767': "+ unionIndex767)); + } + } + int unionIndex768 = (decoder.readIndex()); + if (unionIndex768 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(768, null); + } else { + if (unionIndex768 == 1) { + Utf8 charSequence768; + Object oldString768 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(768); + if (oldString768 instanceof Utf8) { + charSequence768 = (decoder).readString(((Utf8) oldString768)); + } else { + charSequence768 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(768, charSequence768); + } else { + throw new RuntimeException(("Illegal union index for 'F768': "+ unionIndex768)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema384(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex769 = (decoder.readIndex()); + if (unionIndex769 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(769, null); + } else { + if (unionIndex769 == 1) { + Utf8 charSequence769; + Object oldString769 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(769); + if (oldString769 instanceof Utf8) { + charSequence769 = (decoder).readString(((Utf8) oldString769)); + } else { + charSequence769 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(769, charSequence769); + } else { + throw new RuntimeException(("Illegal union index for 'F769': "+ unionIndex769)); + } + } + int unionIndex770 = (decoder.readIndex()); + if (unionIndex770 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(770, null); + } else { + if (unionIndex770 == 1) { + Utf8 charSequence770; + Object oldString770 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(770); + if (oldString770 instanceof Utf8) { + charSequence770 = (decoder).readString(((Utf8) oldString770)); + } else { + charSequence770 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(770, charSequence770); + } else { + throw new RuntimeException(("Illegal union index for 'F770': "+ unionIndex770)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema385(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex771 = (decoder.readIndex()); + if (unionIndex771 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(771, null); + } else { + if (unionIndex771 == 1) { + Utf8 charSequence771; + Object oldString771 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(771); + if (oldString771 instanceof Utf8) { + charSequence771 = (decoder).readString(((Utf8) oldString771)); + } else { + charSequence771 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(771, charSequence771); + } else { + throw new RuntimeException(("Illegal union index for 'F771': "+ unionIndex771)); + } + } + int unionIndex772 = (decoder.readIndex()); + if (unionIndex772 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(772, null); + } else { + if (unionIndex772 == 1) { + Utf8 charSequence772; + Object oldString772 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(772); + if (oldString772 instanceof Utf8) { + charSequence772 = (decoder).readString(((Utf8) oldString772)); + } else { + charSequence772 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(772, charSequence772); + } else { + throw new RuntimeException(("Illegal union index for 'F772': "+ unionIndex772)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema386(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex773 = (decoder.readIndex()); + if (unionIndex773 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(773, null); + } else { + if (unionIndex773 == 1) { + Utf8 charSequence773; + Object oldString773 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(773); + if (oldString773 instanceof Utf8) { + charSequence773 = (decoder).readString(((Utf8) oldString773)); + } else { + charSequence773 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(773, charSequence773); + } else { + throw new RuntimeException(("Illegal union index for 'F773': "+ unionIndex773)); + } + } + int unionIndex774 = (decoder.readIndex()); + if (unionIndex774 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(774, null); + } else { + if (unionIndex774 == 1) { + Utf8 charSequence774; + Object oldString774 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(774); + if (oldString774 instanceof Utf8) { + charSequence774 = (decoder).readString(((Utf8) oldString774)); + } else { + charSequence774 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(774, charSequence774); + } else { + throw new RuntimeException(("Illegal union index for 'F774': "+ unionIndex774)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema387(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex775 = (decoder.readIndex()); + if (unionIndex775 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(775, null); + } else { + if (unionIndex775 == 1) { + Utf8 charSequence775; + Object oldString775 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(775); + if (oldString775 instanceof Utf8) { + charSequence775 = (decoder).readString(((Utf8) oldString775)); + } else { + charSequence775 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(775, charSequence775); + } else { + throw new RuntimeException(("Illegal union index for 'F775': "+ unionIndex775)); + } + } + int unionIndex776 = (decoder.readIndex()); + if (unionIndex776 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(776, null); + } else { + if (unionIndex776 == 1) { + Utf8 charSequence776; + Object oldString776 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(776); + if (oldString776 instanceof Utf8) { + charSequence776 = (decoder).readString(((Utf8) oldString776)); + } else { + charSequence776 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(776, charSequence776); + } else { + throw new RuntimeException(("Illegal union index for 'F776': "+ unionIndex776)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema388(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex777 = (decoder.readIndex()); + if (unionIndex777 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(777, null); + } else { + if (unionIndex777 == 1) { + Utf8 charSequence777; + Object oldString777 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(777); + if (oldString777 instanceof Utf8) { + charSequence777 = (decoder).readString(((Utf8) oldString777)); + } else { + charSequence777 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(777, charSequence777); + } else { + throw new RuntimeException(("Illegal union index for 'F777': "+ unionIndex777)); + } + } + int unionIndex778 = (decoder.readIndex()); + if (unionIndex778 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(778, null); + } else { + if (unionIndex778 == 1) { + Utf8 charSequence778; + Object oldString778 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(778); + if (oldString778 instanceof Utf8) { + charSequence778 = (decoder).readString(((Utf8) oldString778)); + } else { + charSequence778 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(778, charSequence778); + } else { + throw new RuntimeException(("Illegal union index for 'F778': "+ unionIndex778)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema389(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex779 = (decoder.readIndex()); + if (unionIndex779 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(779, null); + } else { + if (unionIndex779 == 1) { + Utf8 charSequence779; + Object oldString779 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(779); + if (oldString779 instanceof Utf8) { + charSequence779 = (decoder).readString(((Utf8) oldString779)); + } else { + charSequence779 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(779, charSequence779); + } else { + throw new RuntimeException(("Illegal union index for 'F779': "+ unionIndex779)); + } + } + int unionIndex780 = (decoder.readIndex()); + if (unionIndex780 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(780, null); + } else { + if (unionIndex780 == 1) { + Utf8 charSequence780; + Object oldString780 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(780); + if (oldString780 instanceof Utf8) { + charSequence780 = (decoder).readString(((Utf8) oldString780)); + } else { + charSequence780 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(780, charSequence780); + } else { + throw new RuntimeException(("Illegal union index for 'F780': "+ unionIndex780)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema390(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex781 = (decoder.readIndex()); + if (unionIndex781 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(781, null); + } else { + if (unionIndex781 == 1) { + Utf8 charSequence781; + Object oldString781 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(781); + if (oldString781 instanceof Utf8) { + charSequence781 = (decoder).readString(((Utf8) oldString781)); + } else { + charSequence781 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(781, charSequence781); + } else { + throw new RuntimeException(("Illegal union index for 'F781': "+ unionIndex781)); + } + } + int unionIndex782 = (decoder.readIndex()); + if (unionIndex782 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(782, null); + } else { + if (unionIndex782 == 1) { + Utf8 charSequence782; + Object oldString782 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(782); + if (oldString782 instanceof Utf8) { + charSequence782 = (decoder).readString(((Utf8) oldString782)); + } else { + charSequence782 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(782, charSequence782); + } else { + throw new RuntimeException(("Illegal union index for 'F782': "+ unionIndex782)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema391(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex783 = (decoder.readIndex()); + if (unionIndex783 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(783, null); + } else { + if (unionIndex783 == 1) { + Utf8 charSequence783; + Object oldString783 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(783); + if (oldString783 instanceof Utf8) { + charSequence783 = (decoder).readString(((Utf8) oldString783)); + } else { + charSequence783 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(783, charSequence783); + } else { + throw new RuntimeException(("Illegal union index for 'F783': "+ unionIndex783)); + } + } + int unionIndex784 = (decoder.readIndex()); + if (unionIndex784 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(784, null); + } else { + if (unionIndex784 == 1) { + Utf8 charSequence784; + Object oldString784 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(784); + if (oldString784 instanceof Utf8) { + charSequence784 = (decoder).readString(((Utf8) oldString784)); + } else { + charSequence784 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(784, charSequence784); + } else { + throw new RuntimeException(("Illegal union index for 'F784': "+ unionIndex784)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema392(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex785 = (decoder.readIndex()); + if (unionIndex785 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(785, null); + } else { + if (unionIndex785 == 1) { + Utf8 charSequence785; + Object oldString785 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(785); + if (oldString785 instanceof Utf8) { + charSequence785 = (decoder).readString(((Utf8) oldString785)); + } else { + charSequence785 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(785, charSequence785); + } else { + throw new RuntimeException(("Illegal union index for 'F785': "+ unionIndex785)); + } + } + int unionIndex786 = (decoder.readIndex()); + if (unionIndex786 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(786, null); + } else { + if (unionIndex786 == 1) { + Utf8 charSequence786; + Object oldString786 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(786); + if (oldString786 instanceof Utf8) { + charSequence786 = (decoder).readString(((Utf8) oldString786)); + } else { + charSequence786 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(786, charSequence786); + } else { + throw new RuntimeException(("Illegal union index for 'F786': "+ unionIndex786)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema393(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex787 = (decoder.readIndex()); + if (unionIndex787 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(787, null); + } else { + if (unionIndex787 == 1) { + Utf8 charSequence787; + Object oldString787 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(787); + if (oldString787 instanceof Utf8) { + charSequence787 = (decoder).readString(((Utf8) oldString787)); + } else { + charSequence787 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(787, charSequence787); + } else { + throw new RuntimeException(("Illegal union index for 'F787': "+ unionIndex787)); + } + } + int unionIndex788 = (decoder.readIndex()); + if (unionIndex788 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(788, null); + } else { + if (unionIndex788 == 1) { + Utf8 charSequence788; + Object oldString788 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(788); + if (oldString788 instanceof Utf8) { + charSequence788 = (decoder).readString(((Utf8) oldString788)); + } else { + charSequence788 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(788, charSequence788); + } else { + throw new RuntimeException(("Illegal union index for 'F788': "+ unionIndex788)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema394(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex789 = (decoder.readIndex()); + if (unionIndex789 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(789, null); + } else { + if (unionIndex789 == 1) { + Utf8 charSequence789; + Object oldString789 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(789); + if (oldString789 instanceof Utf8) { + charSequence789 = (decoder).readString(((Utf8) oldString789)); + } else { + charSequence789 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(789, charSequence789); + } else { + throw new RuntimeException(("Illegal union index for 'F789': "+ unionIndex789)); + } + } + int unionIndex790 = (decoder.readIndex()); + if (unionIndex790 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(790, null); + } else { + if (unionIndex790 == 1) { + Utf8 charSequence790; + Object oldString790 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(790); + if (oldString790 instanceof Utf8) { + charSequence790 = (decoder).readString(((Utf8) oldString790)); + } else { + charSequence790 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(790, charSequence790); + } else { + throw new RuntimeException(("Illegal union index for 'F790': "+ unionIndex790)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema395(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex791 = (decoder.readIndex()); + if (unionIndex791 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(791, null); + } else { + if (unionIndex791 == 1) { + Utf8 charSequence791; + Object oldString791 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(791); + if (oldString791 instanceof Utf8) { + charSequence791 = (decoder).readString(((Utf8) oldString791)); + } else { + charSequence791 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(791, charSequence791); + } else { + throw new RuntimeException(("Illegal union index for 'F791': "+ unionIndex791)); + } + } + int unionIndex792 = (decoder.readIndex()); + if (unionIndex792 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(792, null); + } else { + if (unionIndex792 == 1) { + Utf8 charSequence792; + Object oldString792 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(792); + if (oldString792 instanceof Utf8) { + charSequence792 = (decoder).readString(((Utf8) oldString792)); + } else { + charSequence792 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(792, charSequence792); + } else { + throw new RuntimeException(("Illegal union index for 'F792': "+ unionIndex792)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema396(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex793 = (decoder.readIndex()); + if (unionIndex793 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(793, null); + } else { + if (unionIndex793 == 1) { + Utf8 charSequence793; + Object oldString793 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(793); + if (oldString793 instanceof Utf8) { + charSequence793 = (decoder).readString(((Utf8) oldString793)); + } else { + charSequence793 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(793, charSequence793); + } else { + throw new RuntimeException(("Illegal union index for 'F793': "+ unionIndex793)); + } + } + int unionIndex794 = (decoder.readIndex()); + if (unionIndex794 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(794, null); + } else { + if (unionIndex794 == 1) { + Utf8 charSequence794; + Object oldString794 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(794); + if (oldString794 instanceof Utf8) { + charSequence794 = (decoder).readString(((Utf8) oldString794)); + } else { + charSequence794 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(794, charSequence794); + } else { + throw new RuntimeException(("Illegal union index for 'F794': "+ unionIndex794)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema397(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex795 = (decoder.readIndex()); + if (unionIndex795 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(795, null); + } else { + if (unionIndex795 == 1) { + Utf8 charSequence795; + Object oldString795 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(795); + if (oldString795 instanceof Utf8) { + charSequence795 = (decoder).readString(((Utf8) oldString795)); + } else { + charSequence795 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(795, charSequence795); + } else { + throw new RuntimeException(("Illegal union index for 'F795': "+ unionIndex795)); + } + } + int unionIndex796 = (decoder.readIndex()); + if (unionIndex796 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(796, null); + } else { + if (unionIndex796 == 1) { + Utf8 charSequence796; + Object oldString796 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(796); + if (oldString796 instanceof Utf8) { + charSequence796 = (decoder).readString(((Utf8) oldString796)); + } else { + charSequence796 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(796, charSequence796); + } else { + throw new RuntimeException(("Illegal union index for 'F796': "+ unionIndex796)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema398(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex797 = (decoder.readIndex()); + if (unionIndex797 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(797, null); + } else { + if (unionIndex797 == 1) { + Utf8 charSequence797; + Object oldString797 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(797); + if (oldString797 instanceof Utf8) { + charSequence797 = (decoder).readString(((Utf8) oldString797)); + } else { + charSequence797 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(797, charSequence797); + } else { + throw new RuntimeException(("Illegal union index for 'F797': "+ unionIndex797)); + } + } + int unionIndex798 = (decoder.readIndex()); + if (unionIndex798 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(798, null); + } else { + if (unionIndex798 == 1) { + Utf8 charSequence798; + Object oldString798 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(798); + if (oldString798 instanceof Utf8) { + charSequence798 = (decoder).readString(((Utf8) oldString798)); + } else { + charSequence798 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(798, charSequence798); + } else { + throw new RuntimeException(("Illegal union index for 'F798': "+ unionIndex798)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema399(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex799 = (decoder.readIndex()); + if (unionIndex799 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(799, null); + } else { + if (unionIndex799 == 1) { + Utf8 charSequence799; + Object oldString799 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(799); + if (oldString799 instanceof Utf8) { + charSequence799 = (decoder).readString(((Utf8) oldString799)); + } else { + charSequence799 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(799, charSequence799); + } else { + throw new RuntimeException(("Illegal union index for 'F799': "+ unionIndex799)); + } + } + int unionIndex800 = (decoder.readIndex()); + if (unionIndex800 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(800, null); + } else { + if (unionIndex800 == 1) { + Utf8 charSequence800; + Object oldString800 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(800); + if (oldString800 instanceof Utf8) { + charSequence800 = (decoder).readString(((Utf8) oldString800)); + } else { + charSequence800 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(800, charSequence800); + } else { + throw new RuntimeException(("Illegal union index for 'F800': "+ unionIndex800)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema400(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex801 = (decoder.readIndex()); + if (unionIndex801 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(801, null); + } else { + if (unionIndex801 == 1) { + Utf8 charSequence801; + Object oldString801 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(801); + if (oldString801 instanceof Utf8) { + charSequence801 = (decoder).readString(((Utf8) oldString801)); + } else { + charSequence801 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(801, charSequence801); + } else { + throw new RuntimeException(("Illegal union index for 'F801': "+ unionIndex801)); + } + } + int unionIndex802 = (decoder.readIndex()); + if (unionIndex802 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(802, null); + } else { + if (unionIndex802 == 1) { + Utf8 charSequence802; + Object oldString802 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(802); + if (oldString802 instanceof Utf8) { + charSequence802 = (decoder).readString(((Utf8) oldString802)); + } else { + charSequence802 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(802, charSequence802); + } else { + throw new RuntimeException(("Illegal union index for 'F802': "+ unionIndex802)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema401(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex803 = (decoder.readIndex()); + if (unionIndex803 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(803, null); + } else { + if (unionIndex803 == 1) { + Utf8 charSequence803; + Object oldString803 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(803); + if (oldString803 instanceof Utf8) { + charSequence803 = (decoder).readString(((Utf8) oldString803)); + } else { + charSequence803 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(803, charSequence803); + } else { + throw new RuntimeException(("Illegal union index for 'F803': "+ unionIndex803)); + } + } + int unionIndex804 = (decoder.readIndex()); + if (unionIndex804 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(804, null); + } else { + if (unionIndex804 == 1) { + Utf8 charSequence804; + Object oldString804 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(804); + if (oldString804 instanceof Utf8) { + charSequence804 = (decoder).readString(((Utf8) oldString804)); + } else { + charSequence804 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(804, charSequence804); + } else { + throw new RuntimeException(("Illegal union index for 'F804': "+ unionIndex804)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema402(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex805 = (decoder.readIndex()); + if (unionIndex805 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(805, null); + } else { + if (unionIndex805 == 1) { + Utf8 charSequence805; + Object oldString805 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(805); + if (oldString805 instanceof Utf8) { + charSequence805 = (decoder).readString(((Utf8) oldString805)); + } else { + charSequence805 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(805, charSequence805); + } else { + throw new RuntimeException(("Illegal union index for 'F805': "+ unionIndex805)); + } + } + int unionIndex806 = (decoder.readIndex()); + if (unionIndex806 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(806, null); + } else { + if (unionIndex806 == 1) { + Utf8 charSequence806; + Object oldString806 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(806); + if (oldString806 instanceof Utf8) { + charSequence806 = (decoder).readString(((Utf8) oldString806)); + } else { + charSequence806 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(806, charSequence806); + } else { + throw new RuntimeException(("Illegal union index for 'F806': "+ unionIndex806)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema403(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex807 = (decoder.readIndex()); + if (unionIndex807 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(807, null); + } else { + if (unionIndex807 == 1) { + Utf8 charSequence807; + Object oldString807 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(807); + if (oldString807 instanceof Utf8) { + charSequence807 = (decoder).readString(((Utf8) oldString807)); + } else { + charSequence807 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(807, charSequence807); + } else { + throw new RuntimeException(("Illegal union index for 'F807': "+ unionIndex807)); + } + } + int unionIndex808 = (decoder.readIndex()); + if (unionIndex808 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(808, null); + } else { + if (unionIndex808 == 1) { + Utf8 charSequence808; + Object oldString808 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(808); + if (oldString808 instanceof Utf8) { + charSequence808 = (decoder).readString(((Utf8) oldString808)); + } else { + charSequence808 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(808, charSequence808); + } else { + throw new RuntimeException(("Illegal union index for 'F808': "+ unionIndex808)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema404(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex809 = (decoder.readIndex()); + if (unionIndex809 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(809, null); + } else { + if (unionIndex809 == 1) { + Utf8 charSequence809; + Object oldString809 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(809); + if (oldString809 instanceof Utf8) { + charSequence809 = (decoder).readString(((Utf8) oldString809)); + } else { + charSequence809 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(809, charSequence809); + } else { + throw new RuntimeException(("Illegal union index for 'F809': "+ unionIndex809)); + } + } + int unionIndex810 = (decoder.readIndex()); + if (unionIndex810 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(810, null); + } else { + if (unionIndex810 == 1) { + Utf8 charSequence810; + Object oldString810 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(810); + if (oldString810 instanceof Utf8) { + charSequence810 = (decoder).readString(((Utf8) oldString810)); + } else { + charSequence810 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(810, charSequence810); + } else { + throw new RuntimeException(("Illegal union index for 'F810': "+ unionIndex810)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema405(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex811 = (decoder.readIndex()); + if (unionIndex811 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(811, null); + } else { + if (unionIndex811 == 1) { + Utf8 charSequence811; + Object oldString811 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(811); + if (oldString811 instanceof Utf8) { + charSequence811 = (decoder).readString(((Utf8) oldString811)); + } else { + charSequence811 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(811, charSequence811); + } else { + throw new RuntimeException(("Illegal union index for 'F811': "+ unionIndex811)); + } + } + int unionIndex812 = (decoder.readIndex()); + if (unionIndex812 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(812, null); + } else { + if (unionIndex812 == 1) { + Utf8 charSequence812; + Object oldString812 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(812); + if (oldString812 instanceof Utf8) { + charSequence812 = (decoder).readString(((Utf8) oldString812)); + } else { + charSequence812 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(812, charSequence812); + } else { + throw new RuntimeException(("Illegal union index for 'F812': "+ unionIndex812)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema406(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex813 = (decoder.readIndex()); + if (unionIndex813 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(813, null); + } else { + if (unionIndex813 == 1) { + Utf8 charSequence813; + Object oldString813 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(813); + if (oldString813 instanceof Utf8) { + charSequence813 = (decoder).readString(((Utf8) oldString813)); + } else { + charSequence813 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(813, charSequence813); + } else { + throw new RuntimeException(("Illegal union index for 'F813': "+ unionIndex813)); + } + } + int unionIndex814 = (decoder.readIndex()); + if (unionIndex814 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(814, null); + } else { + if (unionIndex814 == 1) { + Utf8 charSequence814; + Object oldString814 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(814); + if (oldString814 instanceof Utf8) { + charSequence814 = (decoder).readString(((Utf8) oldString814)); + } else { + charSequence814 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(814, charSequence814); + } else { + throw new RuntimeException(("Illegal union index for 'F814': "+ unionIndex814)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema407(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex815 = (decoder.readIndex()); + if (unionIndex815 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(815, null); + } else { + if (unionIndex815 == 1) { + Utf8 charSequence815; + Object oldString815 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(815); + if (oldString815 instanceof Utf8) { + charSequence815 = (decoder).readString(((Utf8) oldString815)); + } else { + charSequence815 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(815, charSequence815); + } else { + throw new RuntimeException(("Illegal union index for 'F815': "+ unionIndex815)); + } + } + int unionIndex816 = (decoder.readIndex()); + if (unionIndex816 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(816, null); + } else { + if (unionIndex816 == 1) { + Utf8 charSequence816; + Object oldString816 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(816); + if (oldString816 instanceof Utf8) { + charSequence816 = (decoder).readString(((Utf8) oldString816)); + } else { + charSequence816 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(816, charSequence816); + } else { + throw new RuntimeException(("Illegal union index for 'F816': "+ unionIndex816)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema408(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex817 = (decoder.readIndex()); + if (unionIndex817 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(817, null); + } else { + if (unionIndex817 == 1) { + Utf8 charSequence817; + Object oldString817 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(817); + if (oldString817 instanceof Utf8) { + charSequence817 = (decoder).readString(((Utf8) oldString817)); + } else { + charSequence817 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(817, charSequence817); + } else { + throw new RuntimeException(("Illegal union index for 'F817': "+ unionIndex817)); + } + } + int unionIndex818 = (decoder.readIndex()); + if (unionIndex818 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(818, null); + } else { + if (unionIndex818 == 1) { + Utf8 charSequence818; + Object oldString818 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(818); + if (oldString818 instanceof Utf8) { + charSequence818 = (decoder).readString(((Utf8) oldString818)); + } else { + charSequence818 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(818, charSequence818); + } else { + throw new RuntimeException(("Illegal union index for 'F818': "+ unionIndex818)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema409(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex819 = (decoder.readIndex()); + if (unionIndex819 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(819, null); + } else { + if (unionIndex819 == 1) { + Utf8 charSequence819; + Object oldString819 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(819); + if (oldString819 instanceof Utf8) { + charSequence819 = (decoder).readString(((Utf8) oldString819)); + } else { + charSequence819 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(819, charSequence819); + } else { + throw new RuntimeException(("Illegal union index for 'F819': "+ unionIndex819)); + } + } + int unionIndex820 = (decoder.readIndex()); + if (unionIndex820 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(820, null); + } else { + if (unionIndex820 == 1) { + Utf8 charSequence820; + Object oldString820 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(820); + if (oldString820 instanceof Utf8) { + charSequence820 = (decoder).readString(((Utf8) oldString820)); + } else { + charSequence820 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(820, charSequence820); + } else { + throw new RuntimeException(("Illegal union index for 'F820': "+ unionIndex820)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema410(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex821 = (decoder.readIndex()); + if (unionIndex821 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(821, null); + } else { + if (unionIndex821 == 1) { + Utf8 charSequence821; + Object oldString821 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(821); + if (oldString821 instanceof Utf8) { + charSequence821 = (decoder).readString(((Utf8) oldString821)); + } else { + charSequence821 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(821, charSequence821); + } else { + throw new RuntimeException(("Illegal union index for 'F821': "+ unionIndex821)); + } + } + int unionIndex822 = (decoder.readIndex()); + if (unionIndex822 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(822, null); + } else { + if (unionIndex822 == 1) { + Utf8 charSequence822; + Object oldString822 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(822); + if (oldString822 instanceof Utf8) { + charSequence822 = (decoder).readString(((Utf8) oldString822)); + } else { + charSequence822 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(822, charSequence822); + } else { + throw new RuntimeException(("Illegal union index for 'F822': "+ unionIndex822)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema411(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex823 = (decoder.readIndex()); + if (unionIndex823 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(823, null); + } else { + if (unionIndex823 == 1) { + Utf8 charSequence823; + Object oldString823 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(823); + if (oldString823 instanceof Utf8) { + charSequence823 = (decoder).readString(((Utf8) oldString823)); + } else { + charSequence823 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(823, charSequence823); + } else { + throw new RuntimeException(("Illegal union index for 'F823': "+ unionIndex823)); + } + } + int unionIndex824 = (decoder.readIndex()); + if (unionIndex824 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(824, null); + } else { + if (unionIndex824 == 1) { + Utf8 charSequence824; + Object oldString824 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(824); + if (oldString824 instanceof Utf8) { + charSequence824 = (decoder).readString(((Utf8) oldString824)); + } else { + charSequence824 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(824, charSequence824); + } else { + throw new RuntimeException(("Illegal union index for 'F824': "+ unionIndex824)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema412(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex825 = (decoder.readIndex()); + if (unionIndex825 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(825, null); + } else { + if (unionIndex825 == 1) { + Utf8 charSequence825; + Object oldString825 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(825); + if (oldString825 instanceof Utf8) { + charSequence825 = (decoder).readString(((Utf8) oldString825)); + } else { + charSequence825 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(825, charSequence825); + } else { + throw new RuntimeException(("Illegal union index for 'F825': "+ unionIndex825)); + } + } + int unionIndex826 = (decoder.readIndex()); + if (unionIndex826 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(826, null); + } else { + if (unionIndex826 == 1) { + Utf8 charSequence826; + Object oldString826 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(826); + if (oldString826 instanceof Utf8) { + charSequence826 = (decoder).readString(((Utf8) oldString826)); + } else { + charSequence826 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(826, charSequence826); + } else { + throw new RuntimeException(("Illegal union index for 'F826': "+ unionIndex826)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema413(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex827 = (decoder.readIndex()); + if (unionIndex827 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(827, null); + } else { + if (unionIndex827 == 1) { + Utf8 charSequence827; + Object oldString827 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(827); + if (oldString827 instanceof Utf8) { + charSequence827 = (decoder).readString(((Utf8) oldString827)); + } else { + charSequence827 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(827, charSequence827); + } else { + throw new RuntimeException(("Illegal union index for 'F827': "+ unionIndex827)); + } + } + int unionIndex828 = (decoder.readIndex()); + if (unionIndex828 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(828, null); + } else { + if (unionIndex828 == 1) { + Utf8 charSequence828; + Object oldString828 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(828); + if (oldString828 instanceof Utf8) { + charSequence828 = (decoder).readString(((Utf8) oldString828)); + } else { + charSequence828 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(828, charSequence828); + } else { + throw new RuntimeException(("Illegal union index for 'F828': "+ unionIndex828)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema414(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex829 = (decoder.readIndex()); + if (unionIndex829 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(829, null); + } else { + if (unionIndex829 == 1) { + Utf8 charSequence829; + Object oldString829 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(829); + if (oldString829 instanceof Utf8) { + charSequence829 = (decoder).readString(((Utf8) oldString829)); + } else { + charSequence829 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(829, charSequence829); + } else { + throw new RuntimeException(("Illegal union index for 'F829': "+ unionIndex829)); + } + } + int unionIndex830 = (decoder.readIndex()); + if (unionIndex830 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(830, null); + } else { + if (unionIndex830 == 1) { + Utf8 charSequence830; + Object oldString830 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(830); + if (oldString830 instanceof Utf8) { + charSequence830 = (decoder).readString(((Utf8) oldString830)); + } else { + charSequence830 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(830, charSequence830); + } else { + throw new RuntimeException(("Illegal union index for 'F830': "+ unionIndex830)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema415(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex831 = (decoder.readIndex()); + if (unionIndex831 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(831, null); + } else { + if (unionIndex831 == 1) { + Utf8 charSequence831; + Object oldString831 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(831); + if (oldString831 instanceof Utf8) { + charSequence831 = (decoder).readString(((Utf8) oldString831)); + } else { + charSequence831 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(831, charSequence831); + } else { + throw new RuntimeException(("Illegal union index for 'F831': "+ unionIndex831)); + } + } + int unionIndex832 = (decoder.readIndex()); + if (unionIndex832 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(832, null); + } else { + if (unionIndex832 == 1) { + Utf8 charSequence832; + Object oldString832 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(832); + if (oldString832 instanceof Utf8) { + charSequence832 = (decoder).readString(((Utf8) oldString832)); + } else { + charSequence832 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(832, charSequence832); + } else { + throw new RuntimeException(("Illegal union index for 'F832': "+ unionIndex832)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema416(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex833 = (decoder.readIndex()); + if (unionIndex833 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(833, null); + } else { + if (unionIndex833 == 1) { + Utf8 charSequence833; + Object oldString833 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(833); + if (oldString833 instanceof Utf8) { + charSequence833 = (decoder).readString(((Utf8) oldString833)); + } else { + charSequence833 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(833, charSequence833); + } else { + throw new RuntimeException(("Illegal union index for 'F833': "+ unionIndex833)); + } + } + int unionIndex834 = (decoder.readIndex()); + if (unionIndex834 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(834, null); + } else { + if (unionIndex834 == 1) { + Utf8 charSequence834; + Object oldString834 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(834); + if (oldString834 instanceof Utf8) { + charSequence834 = (decoder).readString(((Utf8) oldString834)); + } else { + charSequence834 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(834, charSequence834); + } else { + throw new RuntimeException(("Illegal union index for 'F834': "+ unionIndex834)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema417(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex835 = (decoder.readIndex()); + if (unionIndex835 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(835, null); + } else { + if (unionIndex835 == 1) { + Utf8 charSequence835; + Object oldString835 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(835); + if (oldString835 instanceof Utf8) { + charSequence835 = (decoder).readString(((Utf8) oldString835)); + } else { + charSequence835 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(835, charSequence835); + } else { + throw new RuntimeException(("Illegal union index for 'F835': "+ unionIndex835)); + } + } + int unionIndex836 = (decoder.readIndex()); + if (unionIndex836 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(836, null); + } else { + if (unionIndex836 == 1) { + Utf8 charSequence836; + Object oldString836 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(836); + if (oldString836 instanceof Utf8) { + charSequence836 = (decoder).readString(((Utf8) oldString836)); + } else { + charSequence836 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(836, charSequence836); + } else { + throw new RuntimeException(("Illegal union index for 'F836': "+ unionIndex836)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema418(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex837 = (decoder.readIndex()); + if (unionIndex837 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(837, null); + } else { + if (unionIndex837 == 1) { + Utf8 charSequence837; + Object oldString837 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(837); + if (oldString837 instanceof Utf8) { + charSequence837 = (decoder).readString(((Utf8) oldString837)); + } else { + charSequence837 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(837, charSequence837); + } else { + throw new RuntimeException(("Illegal union index for 'F837': "+ unionIndex837)); + } + } + int unionIndex838 = (decoder.readIndex()); + if (unionIndex838 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(838, null); + } else { + if (unionIndex838 == 1) { + Utf8 charSequence838; + Object oldString838 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(838); + if (oldString838 instanceof Utf8) { + charSequence838 = (decoder).readString(((Utf8) oldString838)); + } else { + charSequence838 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(838, charSequence838); + } else { + throw new RuntimeException(("Illegal union index for 'F838': "+ unionIndex838)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema419(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex839 = (decoder.readIndex()); + if (unionIndex839 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(839, null); + } else { + if (unionIndex839 == 1) { + Utf8 charSequence839; + Object oldString839 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(839); + if (oldString839 instanceof Utf8) { + charSequence839 = (decoder).readString(((Utf8) oldString839)); + } else { + charSequence839 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(839, charSequence839); + } else { + throw new RuntimeException(("Illegal union index for 'F839': "+ unionIndex839)); + } + } + int unionIndex840 = (decoder.readIndex()); + if (unionIndex840 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(840, null); + } else { + if (unionIndex840 == 1) { + Utf8 charSequence840; + Object oldString840 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(840); + if (oldString840 instanceof Utf8) { + charSequence840 = (decoder).readString(((Utf8) oldString840)); + } else { + charSequence840 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(840, charSequence840); + } else { + throw new RuntimeException(("Illegal union index for 'F840': "+ unionIndex840)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema420(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex841 = (decoder.readIndex()); + if (unionIndex841 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(841, null); + } else { + if (unionIndex841 == 1) { + Utf8 charSequence841; + Object oldString841 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(841); + if (oldString841 instanceof Utf8) { + charSequence841 = (decoder).readString(((Utf8) oldString841)); + } else { + charSequence841 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(841, charSequence841); + } else { + throw new RuntimeException(("Illegal union index for 'F841': "+ unionIndex841)); + } + } + int unionIndex842 = (decoder.readIndex()); + if (unionIndex842 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(842, null); + } else { + if (unionIndex842 == 1) { + Utf8 charSequence842; + Object oldString842 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(842); + if (oldString842 instanceof Utf8) { + charSequence842 = (decoder).readString(((Utf8) oldString842)); + } else { + charSequence842 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(842, charSequence842); + } else { + throw new RuntimeException(("Illegal union index for 'F842': "+ unionIndex842)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema421(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex843 = (decoder.readIndex()); + if (unionIndex843 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(843, null); + } else { + if (unionIndex843 == 1) { + Utf8 charSequence843; + Object oldString843 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(843); + if (oldString843 instanceof Utf8) { + charSequence843 = (decoder).readString(((Utf8) oldString843)); + } else { + charSequence843 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(843, charSequence843); + } else { + throw new RuntimeException(("Illegal union index for 'F843': "+ unionIndex843)); + } + } + int unionIndex844 = (decoder.readIndex()); + if (unionIndex844 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(844, null); + } else { + if (unionIndex844 == 1) { + Utf8 charSequence844; + Object oldString844 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(844); + if (oldString844 instanceof Utf8) { + charSequence844 = (decoder).readString(((Utf8) oldString844)); + } else { + charSequence844 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(844, charSequence844); + } else { + throw new RuntimeException(("Illegal union index for 'F844': "+ unionIndex844)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema422(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex845 = (decoder.readIndex()); + if (unionIndex845 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(845, null); + } else { + if (unionIndex845 == 1) { + Utf8 charSequence845; + Object oldString845 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(845); + if (oldString845 instanceof Utf8) { + charSequence845 = (decoder).readString(((Utf8) oldString845)); + } else { + charSequence845 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(845, charSequence845); + } else { + throw new RuntimeException(("Illegal union index for 'F845': "+ unionIndex845)); + } + } + int unionIndex846 = (decoder.readIndex()); + if (unionIndex846 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(846, null); + } else { + if (unionIndex846 == 1) { + Utf8 charSequence846; + Object oldString846 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(846); + if (oldString846 instanceof Utf8) { + charSequence846 = (decoder).readString(((Utf8) oldString846)); + } else { + charSequence846 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(846, charSequence846); + } else { + throw new RuntimeException(("Illegal union index for 'F846': "+ unionIndex846)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema423(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex847 = (decoder.readIndex()); + if (unionIndex847 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(847, null); + } else { + if (unionIndex847 == 1) { + Utf8 charSequence847; + Object oldString847 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(847); + if (oldString847 instanceof Utf8) { + charSequence847 = (decoder).readString(((Utf8) oldString847)); + } else { + charSequence847 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(847, charSequence847); + } else { + throw new RuntimeException(("Illegal union index for 'F847': "+ unionIndex847)); + } + } + int unionIndex848 = (decoder.readIndex()); + if (unionIndex848 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(848, null); + } else { + if (unionIndex848 == 1) { + Utf8 charSequence848; + Object oldString848 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(848); + if (oldString848 instanceof Utf8) { + charSequence848 = (decoder).readString(((Utf8) oldString848)); + } else { + charSequence848 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(848, charSequence848); + } else { + throw new RuntimeException(("Illegal union index for 'F848': "+ unionIndex848)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema424(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex849 = (decoder.readIndex()); + if (unionIndex849 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(849, null); + } else { + if (unionIndex849 == 1) { + Utf8 charSequence849; + Object oldString849 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(849); + if (oldString849 instanceof Utf8) { + charSequence849 = (decoder).readString(((Utf8) oldString849)); + } else { + charSequence849 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(849, charSequence849); + } else { + throw new RuntimeException(("Illegal union index for 'F849': "+ unionIndex849)); + } + } + int unionIndex850 = (decoder.readIndex()); + if (unionIndex850 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(850, null); + } else { + if (unionIndex850 == 1) { + Utf8 charSequence850; + Object oldString850 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(850); + if (oldString850 instanceof Utf8) { + charSequence850 = (decoder).readString(((Utf8) oldString850)); + } else { + charSequence850 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(850, charSequence850); + } else { + throw new RuntimeException(("Illegal union index for 'F850': "+ unionIndex850)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema425(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex851 = (decoder.readIndex()); + if (unionIndex851 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(851, null); + } else { + if (unionIndex851 == 1) { + Utf8 charSequence851; + Object oldString851 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(851); + if (oldString851 instanceof Utf8) { + charSequence851 = (decoder).readString(((Utf8) oldString851)); + } else { + charSequence851 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(851, charSequence851); + } else { + throw new RuntimeException(("Illegal union index for 'F851': "+ unionIndex851)); + } + } + int unionIndex852 = (decoder.readIndex()); + if (unionIndex852 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(852, null); + } else { + if (unionIndex852 == 1) { + Utf8 charSequence852; + Object oldString852 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(852); + if (oldString852 instanceof Utf8) { + charSequence852 = (decoder).readString(((Utf8) oldString852)); + } else { + charSequence852 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(852, charSequence852); + } else { + throw new RuntimeException(("Illegal union index for 'F852': "+ unionIndex852)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema426(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex853 = (decoder.readIndex()); + if (unionIndex853 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(853, null); + } else { + if (unionIndex853 == 1) { + Utf8 charSequence853; + Object oldString853 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(853); + if (oldString853 instanceof Utf8) { + charSequence853 = (decoder).readString(((Utf8) oldString853)); + } else { + charSequence853 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(853, charSequence853); + } else { + throw new RuntimeException(("Illegal union index for 'F853': "+ unionIndex853)); + } + } + int unionIndex854 = (decoder.readIndex()); + if (unionIndex854 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(854, null); + } else { + if (unionIndex854 == 1) { + Utf8 charSequence854; + Object oldString854 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(854); + if (oldString854 instanceof Utf8) { + charSequence854 = (decoder).readString(((Utf8) oldString854)); + } else { + charSequence854 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(854, charSequence854); + } else { + throw new RuntimeException(("Illegal union index for 'F854': "+ unionIndex854)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema427(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex855 = (decoder.readIndex()); + if (unionIndex855 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(855, null); + } else { + if (unionIndex855 == 1) { + Utf8 charSequence855; + Object oldString855 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(855); + if (oldString855 instanceof Utf8) { + charSequence855 = (decoder).readString(((Utf8) oldString855)); + } else { + charSequence855 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(855, charSequence855); + } else { + throw new RuntimeException(("Illegal union index for 'F855': "+ unionIndex855)); + } + } + int unionIndex856 = (decoder.readIndex()); + if (unionIndex856 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(856, null); + } else { + if (unionIndex856 == 1) { + Utf8 charSequence856; + Object oldString856 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(856); + if (oldString856 instanceof Utf8) { + charSequence856 = (decoder).readString(((Utf8) oldString856)); + } else { + charSequence856 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(856, charSequence856); + } else { + throw new RuntimeException(("Illegal union index for 'F856': "+ unionIndex856)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema428(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex857 = (decoder.readIndex()); + if (unionIndex857 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(857, null); + } else { + if (unionIndex857 == 1) { + Utf8 charSequence857; + Object oldString857 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(857); + if (oldString857 instanceof Utf8) { + charSequence857 = (decoder).readString(((Utf8) oldString857)); + } else { + charSequence857 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(857, charSequence857); + } else { + throw new RuntimeException(("Illegal union index for 'F857': "+ unionIndex857)); + } + } + int unionIndex858 = (decoder.readIndex()); + if (unionIndex858 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(858, null); + } else { + if (unionIndex858 == 1) { + Utf8 charSequence858; + Object oldString858 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(858); + if (oldString858 instanceof Utf8) { + charSequence858 = (decoder).readString(((Utf8) oldString858)); + } else { + charSequence858 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(858, charSequence858); + } else { + throw new RuntimeException(("Illegal union index for 'F858': "+ unionIndex858)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema429(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex859 = (decoder.readIndex()); + if (unionIndex859 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(859, null); + } else { + if (unionIndex859 == 1) { + Utf8 charSequence859; + Object oldString859 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(859); + if (oldString859 instanceof Utf8) { + charSequence859 = (decoder).readString(((Utf8) oldString859)); + } else { + charSequence859 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(859, charSequence859); + } else { + throw new RuntimeException(("Illegal union index for 'F859': "+ unionIndex859)); + } + } + int unionIndex860 = (decoder.readIndex()); + if (unionIndex860 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(860, null); + } else { + if (unionIndex860 == 1) { + Utf8 charSequence860; + Object oldString860 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(860); + if (oldString860 instanceof Utf8) { + charSequence860 = (decoder).readString(((Utf8) oldString860)); + } else { + charSequence860 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(860, charSequence860); + } else { + throw new RuntimeException(("Illegal union index for 'F860': "+ unionIndex860)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema430(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex861 = (decoder.readIndex()); + if (unionIndex861 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(861, null); + } else { + if (unionIndex861 == 1) { + Utf8 charSequence861; + Object oldString861 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(861); + if (oldString861 instanceof Utf8) { + charSequence861 = (decoder).readString(((Utf8) oldString861)); + } else { + charSequence861 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(861, charSequence861); + } else { + throw new RuntimeException(("Illegal union index for 'F861': "+ unionIndex861)); + } + } + int unionIndex862 = (decoder.readIndex()); + if (unionIndex862 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(862, null); + } else { + if (unionIndex862 == 1) { + Utf8 charSequence862; + Object oldString862 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(862); + if (oldString862 instanceof Utf8) { + charSequence862 = (decoder).readString(((Utf8) oldString862)); + } else { + charSequence862 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(862, charSequence862); + } else { + throw new RuntimeException(("Illegal union index for 'F862': "+ unionIndex862)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema431(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex863 = (decoder.readIndex()); + if (unionIndex863 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(863, null); + } else { + if (unionIndex863 == 1) { + Utf8 charSequence863; + Object oldString863 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(863); + if (oldString863 instanceof Utf8) { + charSequence863 = (decoder).readString(((Utf8) oldString863)); + } else { + charSequence863 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(863, charSequence863); + } else { + throw new RuntimeException(("Illegal union index for 'F863': "+ unionIndex863)); + } + } + int unionIndex864 = (decoder.readIndex()); + if (unionIndex864 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(864, null); + } else { + if (unionIndex864 == 1) { + Utf8 charSequence864; + Object oldString864 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(864); + if (oldString864 instanceof Utf8) { + charSequence864 = (decoder).readString(((Utf8) oldString864)); + } else { + charSequence864 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(864, charSequence864); + } else { + throw new RuntimeException(("Illegal union index for 'F864': "+ unionIndex864)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema432(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex865 = (decoder.readIndex()); + if (unionIndex865 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(865, null); + } else { + if (unionIndex865 == 1) { + Utf8 charSequence865; + Object oldString865 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(865); + if (oldString865 instanceof Utf8) { + charSequence865 = (decoder).readString(((Utf8) oldString865)); + } else { + charSequence865 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(865, charSequence865); + } else { + throw new RuntimeException(("Illegal union index for 'F865': "+ unionIndex865)); + } + } + int unionIndex866 = (decoder.readIndex()); + if (unionIndex866 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(866, null); + } else { + if (unionIndex866 == 1) { + Utf8 charSequence866; + Object oldString866 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(866); + if (oldString866 instanceof Utf8) { + charSequence866 = (decoder).readString(((Utf8) oldString866)); + } else { + charSequence866 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(866, charSequence866); + } else { + throw new RuntimeException(("Illegal union index for 'F866': "+ unionIndex866)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema433(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex867 = (decoder.readIndex()); + if (unionIndex867 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(867, null); + } else { + if (unionIndex867 == 1) { + Utf8 charSequence867; + Object oldString867 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(867); + if (oldString867 instanceof Utf8) { + charSequence867 = (decoder).readString(((Utf8) oldString867)); + } else { + charSequence867 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(867, charSequence867); + } else { + throw new RuntimeException(("Illegal union index for 'F867': "+ unionIndex867)); + } + } + int unionIndex868 = (decoder.readIndex()); + if (unionIndex868 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(868, null); + } else { + if (unionIndex868 == 1) { + Utf8 charSequence868; + Object oldString868 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(868); + if (oldString868 instanceof Utf8) { + charSequence868 = (decoder).readString(((Utf8) oldString868)); + } else { + charSequence868 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(868, charSequence868); + } else { + throw new RuntimeException(("Illegal union index for 'F868': "+ unionIndex868)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema434(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex869 = (decoder.readIndex()); + if (unionIndex869 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(869, null); + } else { + if (unionIndex869 == 1) { + Utf8 charSequence869; + Object oldString869 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(869); + if (oldString869 instanceof Utf8) { + charSequence869 = (decoder).readString(((Utf8) oldString869)); + } else { + charSequence869 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(869, charSequence869); + } else { + throw new RuntimeException(("Illegal union index for 'F869': "+ unionIndex869)); + } + } + int unionIndex870 = (decoder.readIndex()); + if (unionIndex870 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(870, null); + } else { + if (unionIndex870 == 1) { + Utf8 charSequence870; + Object oldString870 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(870); + if (oldString870 instanceof Utf8) { + charSequence870 = (decoder).readString(((Utf8) oldString870)); + } else { + charSequence870 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(870, charSequence870); + } else { + throw new RuntimeException(("Illegal union index for 'F870': "+ unionIndex870)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema435(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex871 = (decoder.readIndex()); + if (unionIndex871 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(871, null); + } else { + if (unionIndex871 == 1) { + Utf8 charSequence871; + Object oldString871 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(871); + if (oldString871 instanceof Utf8) { + charSequence871 = (decoder).readString(((Utf8) oldString871)); + } else { + charSequence871 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(871, charSequence871); + } else { + throw new RuntimeException(("Illegal union index for 'F871': "+ unionIndex871)); + } + } + int unionIndex872 = (decoder.readIndex()); + if (unionIndex872 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(872, null); + } else { + if (unionIndex872 == 1) { + Utf8 charSequence872; + Object oldString872 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(872); + if (oldString872 instanceof Utf8) { + charSequence872 = (decoder).readString(((Utf8) oldString872)); + } else { + charSequence872 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(872, charSequence872); + } else { + throw new RuntimeException(("Illegal union index for 'F872': "+ unionIndex872)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema436(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex873 = (decoder.readIndex()); + if (unionIndex873 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(873, null); + } else { + if (unionIndex873 == 1) { + Utf8 charSequence873; + Object oldString873 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(873); + if (oldString873 instanceof Utf8) { + charSequence873 = (decoder).readString(((Utf8) oldString873)); + } else { + charSequence873 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(873, charSequence873); + } else { + throw new RuntimeException(("Illegal union index for 'F873': "+ unionIndex873)); + } + } + int unionIndex874 = (decoder.readIndex()); + if (unionIndex874 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(874, null); + } else { + if (unionIndex874 == 1) { + Utf8 charSequence874; + Object oldString874 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(874); + if (oldString874 instanceof Utf8) { + charSequence874 = (decoder).readString(((Utf8) oldString874)); + } else { + charSequence874 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(874, charSequence874); + } else { + throw new RuntimeException(("Illegal union index for 'F874': "+ unionIndex874)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema437(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex875 = (decoder.readIndex()); + if (unionIndex875 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(875, null); + } else { + if (unionIndex875 == 1) { + Utf8 charSequence875; + Object oldString875 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(875); + if (oldString875 instanceof Utf8) { + charSequence875 = (decoder).readString(((Utf8) oldString875)); + } else { + charSequence875 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(875, charSequence875); + } else { + throw new RuntimeException(("Illegal union index for 'F875': "+ unionIndex875)); + } + } + int unionIndex876 = (decoder.readIndex()); + if (unionIndex876 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(876, null); + } else { + if (unionIndex876 == 1) { + Utf8 charSequence876; + Object oldString876 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(876); + if (oldString876 instanceof Utf8) { + charSequence876 = (decoder).readString(((Utf8) oldString876)); + } else { + charSequence876 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(876, charSequence876); + } else { + throw new RuntimeException(("Illegal union index for 'F876': "+ unionIndex876)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema438(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex877 = (decoder.readIndex()); + if (unionIndex877 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(877, null); + } else { + if (unionIndex877 == 1) { + Utf8 charSequence877; + Object oldString877 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(877); + if (oldString877 instanceof Utf8) { + charSequence877 = (decoder).readString(((Utf8) oldString877)); + } else { + charSequence877 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(877, charSequence877); + } else { + throw new RuntimeException(("Illegal union index for 'F877': "+ unionIndex877)); + } + } + int unionIndex878 = (decoder.readIndex()); + if (unionIndex878 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(878, null); + } else { + if (unionIndex878 == 1) { + Utf8 charSequence878; + Object oldString878 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(878); + if (oldString878 instanceof Utf8) { + charSequence878 = (decoder).readString(((Utf8) oldString878)); + } else { + charSequence878 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(878, charSequence878); + } else { + throw new RuntimeException(("Illegal union index for 'F878': "+ unionIndex878)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema439(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex879 = (decoder.readIndex()); + if (unionIndex879 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(879, null); + } else { + if (unionIndex879 == 1) { + Utf8 charSequence879; + Object oldString879 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(879); + if (oldString879 instanceof Utf8) { + charSequence879 = (decoder).readString(((Utf8) oldString879)); + } else { + charSequence879 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(879, charSequence879); + } else { + throw new RuntimeException(("Illegal union index for 'F879': "+ unionIndex879)); + } + } + int unionIndex880 = (decoder.readIndex()); + if (unionIndex880 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(880, null); + } else { + if (unionIndex880 == 1) { + Utf8 charSequence880; + Object oldString880 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(880); + if (oldString880 instanceof Utf8) { + charSequence880 = (decoder).readString(((Utf8) oldString880)); + } else { + charSequence880 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(880, charSequence880); + } else { + throw new RuntimeException(("Illegal union index for 'F880': "+ unionIndex880)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema440(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex881 = (decoder.readIndex()); + if (unionIndex881 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(881, null); + } else { + if (unionIndex881 == 1) { + Utf8 charSequence881; + Object oldString881 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(881); + if (oldString881 instanceof Utf8) { + charSequence881 = (decoder).readString(((Utf8) oldString881)); + } else { + charSequence881 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(881, charSequence881); + } else { + throw new RuntimeException(("Illegal union index for 'F881': "+ unionIndex881)); + } + } + int unionIndex882 = (decoder.readIndex()); + if (unionIndex882 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(882, null); + } else { + if (unionIndex882 == 1) { + Utf8 charSequence882; + Object oldString882 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(882); + if (oldString882 instanceof Utf8) { + charSequence882 = (decoder).readString(((Utf8) oldString882)); + } else { + charSequence882 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(882, charSequence882); + } else { + throw new RuntimeException(("Illegal union index for 'F882': "+ unionIndex882)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema441(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex883 = (decoder.readIndex()); + if (unionIndex883 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(883, null); + } else { + if (unionIndex883 == 1) { + Utf8 charSequence883; + Object oldString883 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(883); + if (oldString883 instanceof Utf8) { + charSequence883 = (decoder).readString(((Utf8) oldString883)); + } else { + charSequence883 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(883, charSequence883); + } else { + throw new RuntimeException(("Illegal union index for 'F883': "+ unionIndex883)); + } + } + int unionIndex884 = (decoder.readIndex()); + if (unionIndex884 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(884, null); + } else { + if (unionIndex884 == 1) { + Utf8 charSequence884; + Object oldString884 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(884); + if (oldString884 instanceof Utf8) { + charSequence884 = (decoder).readString(((Utf8) oldString884)); + } else { + charSequence884 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(884, charSequence884); + } else { + throw new RuntimeException(("Illegal union index for 'F884': "+ unionIndex884)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema442(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex885 = (decoder.readIndex()); + if (unionIndex885 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(885, null); + } else { + if (unionIndex885 == 1) { + Utf8 charSequence885; + Object oldString885 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(885); + if (oldString885 instanceof Utf8) { + charSequence885 = (decoder).readString(((Utf8) oldString885)); + } else { + charSequence885 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(885, charSequence885); + } else { + throw new RuntimeException(("Illegal union index for 'F885': "+ unionIndex885)); + } + } + int unionIndex886 = (decoder.readIndex()); + if (unionIndex886 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(886, null); + } else { + if (unionIndex886 == 1) { + Utf8 charSequence886; + Object oldString886 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(886); + if (oldString886 instanceof Utf8) { + charSequence886 = (decoder).readString(((Utf8) oldString886)); + } else { + charSequence886 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(886, charSequence886); + } else { + throw new RuntimeException(("Illegal union index for 'F886': "+ unionIndex886)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema443(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex887 = (decoder.readIndex()); + if (unionIndex887 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(887, null); + } else { + if (unionIndex887 == 1) { + Utf8 charSequence887; + Object oldString887 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(887); + if (oldString887 instanceof Utf8) { + charSequence887 = (decoder).readString(((Utf8) oldString887)); + } else { + charSequence887 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(887, charSequence887); + } else { + throw new RuntimeException(("Illegal union index for 'F887': "+ unionIndex887)); + } + } + int unionIndex888 = (decoder.readIndex()); + if (unionIndex888 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(888, null); + } else { + if (unionIndex888 == 1) { + Utf8 charSequence888; + Object oldString888 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(888); + if (oldString888 instanceof Utf8) { + charSequence888 = (decoder).readString(((Utf8) oldString888)); + } else { + charSequence888 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(888, charSequence888); + } else { + throw new RuntimeException(("Illegal union index for 'F888': "+ unionIndex888)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema444(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex889 = (decoder.readIndex()); + if (unionIndex889 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(889, null); + } else { + if (unionIndex889 == 1) { + Utf8 charSequence889; + Object oldString889 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(889); + if (oldString889 instanceof Utf8) { + charSequence889 = (decoder).readString(((Utf8) oldString889)); + } else { + charSequence889 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(889, charSequence889); + } else { + throw new RuntimeException(("Illegal union index for 'F889': "+ unionIndex889)); + } + } + int unionIndex890 = (decoder.readIndex()); + if (unionIndex890 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(890, null); + } else { + if (unionIndex890 == 1) { + Utf8 charSequence890; + Object oldString890 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(890); + if (oldString890 instanceof Utf8) { + charSequence890 = (decoder).readString(((Utf8) oldString890)); + } else { + charSequence890 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(890, charSequence890); + } else { + throw new RuntimeException(("Illegal union index for 'F890': "+ unionIndex890)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema445(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex891 = (decoder.readIndex()); + if (unionIndex891 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(891, null); + } else { + if (unionIndex891 == 1) { + Utf8 charSequence891; + Object oldString891 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(891); + if (oldString891 instanceof Utf8) { + charSequence891 = (decoder).readString(((Utf8) oldString891)); + } else { + charSequence891 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(891, charSequence891); + } else { + throw new RuntimeException(("Illegal union index for 'F891': "+ unionIndex891)); + } + } + int unionIndex892 = (decoder.readIndex()); + if (unionIndex892 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(892, null); + } else { + if (unionIndex892 == 1) { + Utf8 charSequence892; + Object oldString892 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(892); + if (oldString892 instanceof Utf8) { + charSequence892 = (decoder).readString(((Utf8) oldString892)); + } else { + charSequence892 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(892, charSequence892); + } else { + throw new RuntimeException(("Illegal union index for 'F892': "+ unionIndex892)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema446(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex893 = (decoder.readIndex()); + if (unionIndex893 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(893, null); + } else { + if (unionIndex893 == 1) { + Utf8 charSequence893; + Object oldString893 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(893); + if (oldString893 instanceof Utf8) { + charSequence893 = (decoder).readString(((Utf8) oldString893)); + } else { + charSequence893 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(893, charSequence893); + } else { + throw new RuntimeException(("Illegal union index for 'F893': "+ unionIndex893)); + } + } + int unionIndex894 = (decoder.readIndex()); + if (unionIndex894 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(894, null); + } else { + if (unionIndex894 == 1) { + Utf8 charSequence894; + Object oldString894 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(894); + if (oldString894 instanceof Utf8) { + charSequence894 = (decoder).readString(((Utf8) oldString894)); + } else { + charSequence894 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(894, charSequence894); + } else { + throw new RuntimeException(("Illegal union index for 'F894': "+ unionIndex894)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema447(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex895 = (decoder.readIndex()); + if (unionIndex895 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(895, null); + } else { + if (unionIndex895 == 1) { + Utf8 charSequence895; + Object oldString895 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(895); + if (oldString895 instanceof Utf8) { + charSequence895 = (decoder).readString(((Utf8) oldString895)); + } else { + charSequence895 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(895, charSequence895); + } else { + throw new RuntimeException(("Illegal union index for 'F895': "+ unionIndex895)); + } + } + int unionIndex896 = (decoder.readIndex()); + if (unionIndex896 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(896, null); + } else { + if (unionIndex896 == 1) { + Utf8 charSequence896; + Object oldString896 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(896); + if (oldString896 instanceof Utf8) { + charSequence896 = (decoder).readString(((Utf8) oldString896)); + } else { + charSequence896 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(896, charSequence896); + } else { + throw new RuntimeException(("Illegal union index for 'F896': "+ unionIndex896)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema448(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex897 = (decoder.readIndex()); + if (unionIndex897 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(897, null); + } else { + if (unionIndex897 == 1) { + Utf8 charSequence897; + Object oldString897 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(897); + if (oldString897 instanceof Utf8) { + charSequence897 = (decoder).readString(((Utf8) oldString897)); + } else { + charSequence897 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(897, charSequence897); + } else { + throw new RuntimeException(("Illegal union index for 'F897': "+ unionIndex897)); + } + } + int unionIndex898 = (decoder.readIndex()); + if (unionIndex898 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(898, null); + } else { + if (unionIndex898 == 1) { + Utf8 charSequence898; + Object oldString898 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(898); + if (oldString898 instanceof Utf8) { + charSequence898 = (decoder).readString(((Utf8) oldString898)); + } else { + charSequence898 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(898, charSequence898); + } else { + throw new RuntimeException(("Illegal union index for 'F898': "+ unionIndex898)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema449(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex899 = (decoder.readIndex()); + if (unionIndex899 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(899, null); + } else { + if (unionIndex899 == 1) { + Utf8 charSequence899; + Object oldString899 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(899); + if (oldString899 instanceof Utf8) { + charSequence899 = (decoder).readString(((Utf8) oldString899)); + } else { + charSequence899 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(899, charSequence899); + } else { + throw new RuntimeException(("Illegal union index for 'F899': "+ unionIndex899)); + } + } + int unionIndex900 = (decoder.readIndex()); + if (unionIndex900 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(900, null); + } else { + if (unionIndex900 == 1) { + Utf8 charSequence900; + Object oldString900 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(900); + if (oldString900 instanceof Utf8) { + charSequence900 = (decoder).readString(((Utf8) oldString900)); + } else { + charSequence900 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(900, charSequence900); + } else { + throw new RuntimeException(("Illegal union index for 'F900': "+ unionIndex900)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema450(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex901 = (decoder.readIndex()); + if (unionIndex901 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(901, null); + } else { + if (unionIndex901 == 1) { + Utf8 charSequence901; + Object oldString901 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(901); + if (oldString901 instanceof Utf8) { + charSequence901 = (decoder).readString(((Utf8) oldString901)); + } else { + charSequence901 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(901, charSequence901); + } else { + throw new RuntimeException(("Illegal union index for 'F901': "+ unionIndex901)); + } + } + int unionIndex902 = (decoder.readIndex()); + if (unionIndex902 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(902, null); + } else { + if (unionIndex902 == 1) { + Utf8 charSequence902; + Object oldString902 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(902); + if (oldString902 instanceof Utf8) { + charSequence902 = (decoder).readString(((Utf8) oldString902)); + } else { + charSequence902 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(902, charSequence902); + } else { + throw new RuntimeException(("Illegal union index for 'F902': "+ unionIndex902)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema451(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex903 = (decoder.readIndex()); + if (unionIndex903 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(903, null); + } else { + if (unionIndex903 == 1) { + Utf8 charSequence903; + Object oldString903 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(903); + if (oldString903 instanceof Utf8) { + charSequence903 = (decoder).readString(((Utf8) oldString903)); + } else { + charSequence903 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(903, charSequence903); + } else { + throw new RuntimeException(("Illegal union index for 'F903': "+ unionIndex903)); + } + } + int unionIndex904 = (decoder.readIndex()); + if (unionIndex904 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(904, null); + } else { + if (unionIndex904 == 1) { + Utf8 charSequence904; + Object oldString904 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(904); + if (oldString904 instanceof Utf8) { + charSequence904 = (decoder).readString(((Utf8) oldString904)); + } else { + charSequence904 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(904, charSequence904); + } else { + throw new RuntimeException(("Illegal union index for 'F904': "+ unionIndex904)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema452(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex905 = (decoder.readIndex()); + if (unionIndex905 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(905, null); + } else { + if (unionIndex905 == 1) { + Utf8 charSequence905; + Object oldString905 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(905); + if (oldString905 instanceof Utf8) { + charSequence905 = (decoder).readString(((Utf8) oldString905)); + } else { + charSequence905 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(905, charSequence905); + } else { + throw new RuntimeException(("Illegal union index for 'F905': "+ unionIndex905)); + } + } + int unionIndex906 = (decoder.readIndex()); + if (unionIndex906 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(906, null); + } else { + if (unionIndex906 == 1) { + Utf8 charSequence906; + Object oldString906 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(906); + if (oldString906 instanceof Utf8) { + charSequence906 = (decoder).readString(((Utf8) oldString906)); + } else { + charSequence906 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(906, charSequence906); + } else { + throw new RuntimeException(("Illegal union index for 'F906': "+ unionIndex906)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema453(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex907 = (decoder.readIndex()); + if (unionIndex907 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(907, null); + } else { + if (unionIndex907 == 1) { + Utf8 charSequence907; + Object oldString907 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(907); + if (oldString907 instanceof Utf8) { + charSequence907 = (decoder).readString(((Utf8) oldString907)); + } else { + charSequence907 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(907, charSequence907); + } else { + throw new RuntimeException(("Illegal union index for 'F907': "+ unionIndex907)); + } + } + int unionIndex908 = (decoder.readIndex()); + if (unionIndex908 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(908, null); + } else { + if (unionIndex908 == 1) { + Utf8 charSequence908; + Object oldString908 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(908); + if (oldString908 instanceof Utf8) { + charSequence908 = (decoder).readString(((Utf8) oldString908)); + } else { + charSequence908 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(908, charSequence908); + } else { + throw new RuntimeException(("Illegal union index for 'F908': "+ unionIndex908)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema454(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex909 = (decoder.readIndex()); + if (unionIndex909 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(909, null); + } else { + if (unionIndex909 == 1) { + Utf8 charSequence909; + Object oldString909 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(909); + if (oldString909 instanceof Utf8) { + charSequence909 = (decoder).readString(((Utf8) oldString909)); + } else { + charSequence909 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(909, charSequence909); + } else { + throw new RuntimeException(("Illegal union index for 'F909': "+ unionIndex909)); + } + } + int unionIndex910 = (decoder.readIndex()); + if (unionIndex910 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(910, null); + } else { + if (unionIndex910 == 1) { + Utf8 charSequence910; + Object oldString910 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(910); + if (oldString910 instanceof Utf8) { + charSequence910 = (decoder).readString(((Utf8) oldString910)); + } else { + charSequence910 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(910, charSequence910); + } else { + throw new RuntimeException(("Illegal union index for 'F910': "+ unionIndex910)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema455(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex911 = (decoder.readIndex()); + if (unionIndex911 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(911, null); + } else { + if (unionIndex911 == 1) { + Utf8 charSequence911; + Object oldString911 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(911); + if (oldString911 instanceof Utf8) { + charSequence911 = (decoder).readString(((Utf8) oldString911)); + } else { + charSequence911 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(911, charSequence911); + } else { + throw new RuntimeException(("Illegal union index for 'F911': "+ unionIndex911)); + } + } + int unionIndex912 = (decoder.readIndex()); + if (unionIndex912 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(912, null); + } else { + if (unionIndex912 == 1) { + Utf8 charSequence912; + Object oldString912 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(912); + if (oldString912 instanceof Utf8) { + charSequence912 = (decoder).readString(((Utf8) oldString912)); + } else { + charSequence912 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(912, charSequence912); + } else { + throw new RuntimeException(("Illegal union index for 'F912': "+ unionIndex912)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema456(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex913 = (decoder.readIndex()); + if (unionIndex913 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(913, null); + } else { + if (unionIndex913 == 1) { + Utf8 charSequence913; + Object oldString913 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(913); + if (oldString913 instanceof Utf8) { + charSequence913 = (decoder).readString(((Utf8) oldString913)); + } else { + charSequence913 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(913, charSequence913); + } else { + throw new RuntimeException(("Illegal union index for 'F913': "+ unionIndex913)); + } + } + int unionIndex914 = (decoder.readIndex()); + if (unionIndex914 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(914, null); + } else { + if (unionIndex914 == 1) { + Utf8 charSequence914; + Object oldString914 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(914); + if (oldString914 instanceof Utf8) { + charSequence914 = (decoder).readString(((Utf8) oldString914)); + } else { + charSequence914 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(914, charSequence914); + } else { + throw new RuntimeException(("Illegal union index for 'F914': "+ unionIndex914)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema457(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex915 = (decoder.readIndex()); + if (unionIndex915 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(915, null); + } else { + if (unionIndex915 == 1) { + Utf8 charSequence915; + Object oldString915 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(915); + if (oldString915 instanceof Utf8) { + charSequence915 = (decoder).readString(((Utf8) oldString915)); + } else { + charSequence915 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(915, charSequence915); + } else { + throw new RuntimeException(("Illegal union index for 'F915': "+ unionIndex915)); + } + } + int unionIndex916 = (decoder.readIndex()); + if (unionIndex916 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(916, null); + } else { + if (unionIndex916 == 1) { + Utf8 charSequence916; + Object oldString916 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(916); + if (oldString916 instanceof Utf8) { + charSequence916 = (decoder).readString(((Utf8) oldString916)); + } else { + charSequence916 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(916, charSequence916); + } else { + throw new RuntimeException(("Illegal union index for 'F916': "+ unionIndex916)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema458(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex917 = (decoder.readIndex()); + if (unionIndex917 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(917, null); + } else { + if (unionIndex917 == 1) { + Utf8 charSequence917; + Object oldString917 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(917); + if (oldString917 instanceof Utf8) { + charSequence917 = (decoder).readString(((Utf8) oldString917)); + } else { + charSequence917 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(917, charSequence917); + } else { + throw new RuntimeException(("Illegal union index for 'F917': "+ unionIndex917)); + } + } + int unionIndex918 = (decoder.readIndex()); + if (unionIndex918 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(918, null); + } else { + if (unionIndex918 == 1) { + Utf8 charSequence918; + Object oldString918 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(918); + if (oldString918 instanceof Utf8) { + charSequence918 = (decoder).readString(((Utf8) oldString918)); + } else { + charSequence918 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(918, charSequence918); + } else { + throw new RuntimeException(("Illegal union index for 'F918': "+ unionIndex918)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema459(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex919 = (decoder.readIndex()); + if (unionIndex919 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(919, null); + } else { + if (unionIndex919 == 1) { + Utf8 charSequence919; + Object oldString919 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(919); + if (oldString919 instanceof Utf8) { + charSequence919 = (decoder).readString(((Utf8) oldString919)); + } else { + charSequence919 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(919, charSequence919); + } else { + throw new RuntimeException(("Illegal union index for 'F919': "+ unionIndex919)); + } + } + int unionIndex920 = (decoder.readIndex()); + if (unionIndex920 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(920, null); + } else { + if (unionIndex920 == 1) { + Utf8 charSequence920; + Object oldString920 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(920); + if (oldString920 instanceof Utf8) { + charSequence920 = (decoder).readString(((Utf8) oldString920)); + } else { + charSequence920 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(920, charSequence920); + } else { + throw new RuntimeException(("Illegal union index for 'F920': "+ unionIndex920)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema460(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex921 = (decoder.readIndex()); + if (unionIndex921 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(921, null); + } else { + if (unionIndex921 == 1) { + Utf8 charSequence921; + Object oldString921 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(921); + if (oldString921 instanceof Utf8) { + charSequence921 = (decoder).readString(((Utf8) oldString921)); + } else { + charSequence921 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(921, charSequence921); + } else { + throw new RuntimeException(("Illegal union index for 'F921': "+ unionIndex921)); + } + } + int unionIndex922 = (decoder.readIndex()); + if (unionIndex922 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(922, null); + } else { + if (unionIndex922 == 1) { + Utf8 charSequence922; + Object oldString922 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(922); + if (oldString922 instanceof Utf8) { + charSequence922 = (decoder).readString(((Utf8) oldString922)); + } else { + charSequence922 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(922, charSequence922); + } else { + throw new RuntimeException(("Illegal union index for 'F922': "+ unionIndex922)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema461(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex923 = (decoder.readIndex()); + if (unionIndex923 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(923, null); + } else { + if (unionIndex923 == 1) { + Utf8 charSequence923; + Object oldString923 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(923); + if (oldString923 instanceof Utf8) { + charSequence923 = (decoder).readString(((Utf8) oldString923)); + } else { + charSequence923 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(923, charSequence923); + } else { + throw new RuntimeException(("Illegal union index for 'F923': "+ unionIndex923)); + } + } + int unionIndex924 = (decoder.readIndex()); + if (unionIndex924 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(924, null); + } else { + if (unionIndex924 == 1) { + Utf8 charSequence924; + Object oldString924 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(924); + if (oldString924 instanceof Utf8) { + charSequence924 = (decoder).readString(((Utf8) oldString924)); + } else { + charSequence924 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(924, charSequence924); + } else { + throw new RuntimeException(("Illegal union index for 'F924': "+ unionIndex924)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema462(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex925 = (decoder.readIndex()); + if (unionIndex925 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(925, null); + } else { + if (unionIndex925 == 1) { + Utf8 charSequence925; + Object oldString925 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(925); + if (oldString925 instanceof Utf8) { + charSequence925 = (decoder).readString(((Utf8) oldString925)); + } else { + charSequence925 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(925, charSequence925); + } else { + throw new RuntimeException(("Illegal union index for 'F925': "+ unionIndex925)); + } + } + int unionIndex926 = (decoder.readIndex()); + if (unionIndex926 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(926, null); + } else { + if (unionIndex926 == 1) { + Utf8 charSequence926; + Object oldString926 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(926); + if (oldString926 instanceof Utf8) { + charSequence926 = (decoder).readString(((Utf8) oldString926)); + } else { + charSequence926 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(926, charSequence926); + } else { + throw new RuntimeException(("Illegal union index for 'F926': "+ unionIndex926)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema463(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex927 = (decoder.readIndex()); + if (unionIndex927 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(927, null); + } else { + if (unionIndex927 == 1) { + Utf8 charSequence927; + Object oldString927 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(927); + if (oldString927 instanceof Utf8) { + charSequence927 = (decoder).readString(((Utf8) oldString927)); + } else { + charSequence927 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(927, charSequence927); + } else { + throw new RuntimeException(("Illegal union index for 'F927': "+ unionIndex927)); + } + } + int unionIndex928 = (decoder.readIndex()); + if (unionIndex928 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(928, null); + } else { + if (unionIndex928 == 1) { + Utf8 charSequence928; + Object oldString928 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(928); + if (oldString928 instanceof Utf8) { + charSequence928 = (decoder).readString(((Utf8) oldString928)); + } else { + charSequence928 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(928, charSequence928); + } else { + throw new RuntimeException(("Illegal union index for 'F928': "+ unionIndex928)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema464(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex929 = (decoder.readIndex()); + if (unionIndex929 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(929, null); + } else { + if (unionIndex929 == 1) { + Utf8 charSequence929; + Object oldString929 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(929); + if (oldString929 instanceof Utf8) { + charSequence929 = (decoder).readString(((Utf8) oldString929)); + } else { + charSequence929 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(929, charSequence929); + } else { + throw new RuntimeException(("Illegal union index for 'F929': "+ unionIndex929)); + } + } + int unionIndex930 = (decoder.readIndex()); + if (unionIndex930 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(930, null); + } else { + if (unionIndex930 == 1) { + Utf8 charSequence930; + Object oldString930 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(930); + if (oldString930 instanceof Utf8) { + charSequence930 = (decoder).readString(((Utf8) oldString930)); + } else { + charSequence930 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(930, charSequence930); + } else { + throw new RuntimeException(("Illegal union index for 'F930': "+ unionIndex930)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema465(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex931 = (decoder.readIndex()); + if (unionIndex931 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(931, null); + } else { + if (unionIndex931 == 1) { + Utf8 charSequence931; + Object oldString931 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(931); + if (oldString931 instanceof Utf8) { + charSequence931 = (decoder).readString(((Utf8) oldString931)); + } else { + charSequence931 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(931, charSequence931); + } else { + throw new RuntimeException(("Illegal union index for 'F931': "+ unionIndex931)); + } + } + int unionIndex932 = (decoder.readIndex()); + if (unionIndex932 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(932, null); + } else { + if (unionIndex932 == 1) { + Utf8 charSequence932; + Object oldString932 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(932); + if (oldString932 instanceof Utf8) { + charSequence932 = (decoder).readString(((Utf8) oldString932)); + } else { + charSequence932 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(932, charSequence932); + } else { + throw new RuntimeException(("Illegal union index for 'F932': "+ unionIndex932)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema466(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex933 = (decoder.readIndex()); + if (unionIndex933 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(933, null); + } else { + if (unionIndex933 == 1) { + Utf8 charSequence933; + Object oldString933 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(933); + if (oldString933 instanceof Utf8) { + charSequence933 = (decoder).readString(((Utf8) oldString933)); + } else { + charSequence933 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(933, charSequence933); + } else { + throw new RuntimeException(("Illegal union index for 'F933': "+ unionIndex933)); + } + } + int unionIndex934 = (decoder.readIndex()); + if (unionIndex934 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(934, null); + } else { + if (unionIndex934 == 1) { + Utf8 charSequence934; + Object oldString934 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(934); + if (oldString934 instanceof Utf8) { + charSequence934 = (decoder).readString(((Utf8) oldString934)); + } else { + charSequence934 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(934, charSequence934); + } else { + throw new RuntimeException(("Illegal union index for 'F934': "+ unionIndex934)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema467(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex935 = (decoder.readIndex()); + if (unionIndex935 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(935, null); + } else { + if (unionIndex935 == 1) { + Utf8 charSequence935; + Object oldString935 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(935); + if (oldString935 instanceof Utf8) { + charSequence935 = (decoder).readString(((Utf8) oldString935)); + } else { + charSequence935 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(935, charSequence935); + } else { + throw new RuntimeException(("Illegal union index for 'F935': "+ unionIndex935)); + } + } + int unionIndex936 = (decoder.readIndex()); + if (unionIndex936 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(936, null); + } else { + if (unionIndex936 == 1) { + Utf8 charSequence936; + Object oldString936 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(936); + if (oldString936 instanceof Utf8) { + charSequence936 = (decoder).readString(((Utf8) oldString936)); + } else { + charSequence936 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(936, charSequence936); + } else { + throw new RuntimeException(("Illegal union index for 'F936': "+ unionIndex936)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema468(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex937 = (decoder.readIndex()); + if (unionIndex937 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(937, null); + } else { + if (unionIndex937 == 1) { + Utf8 charSequence937; + Object oldString937 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(937); + if (oldString937 instanceof Utf8) { + charSequence937 = (decoder).readString(((Utf8) oldString937)); + } else { + charSequence937 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(937, charSequence937); + } else { + throw new RuntimeException(("Illegal union index for 'F937': "+ unionIndex937)); + } + } + int unionIndex938 = (decoder.readIndex()); + if (unionIndex938 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(938, null); + } else { + if (unionIndex938 == 1) { + Utf8 charSequence938; + Object oldString938 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(938); + if (oldString938 instanceof Utf8) { + charSequence938 = (decoder).readString(((Utf8) oldString938)); + } else { + charSequence938 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(938, charSequence938); + } else { + throw new RuntimeException(("Illegal union index for 'F938': "+ unionIndex938)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema469(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex939 = (decoder.readIndex()); + if (unionIndex939 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(939, null); + } else { + if (unionIndex939 == 1) { + Utf8 charSequence939; + Object oldString939 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(939); + if (oldString939 instanceof Utf8) { + charSequence939 = (decoder).readString(((Utf8) oldString939)); + } else { + charSequence939 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(939, charSequence939); + } else { + throw new RuntimeException(("Illegal union index for 'F939': "+ unionIndex939)); + } + } + int unionIndex940 = (decoder.readIndex()); + if (unionIndex940 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(940, null); + } else { + if (unionIndex940 == 1) { + Utf8 charSequence940; + Object oldString940 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(940); + if (oldString940 instanceof Utf8) { + charSequence940 = (decoder).readString(((Utf8) oldString940)); + } else { + charSequence940 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(940, charSequence940); + } else { + throw new RuntimeException(("Illegal union index for 'F940': "+ unionIndex940)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema470(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex941 = (decoder.readIndex()); + if (unionIndex941 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(941, null); + } else { + if (unionIndex941 == 1) { + Utf8 charSequence941; + Object oldString941 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(941); + if (oldString941 instanceof Utf8) { + charSequence941 = (decoder).readString(((Utf8) oldString941)); + } else { + charSequence941 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(941, charSequence941); + } else { + throw new RuntimeException(("Illegal union index for 'F941': "+ unionIndex941)); + } + } + int unionIndex942 = (decoder.readIndex()); + if (unionIndex942 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(942, null); + } else { + if (unionIndex942 == 1) { + Utf8 charSequence942; + Object oldString942 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(942); + if (oldString942 instanceof Utf8) { + charSequence942 = (decoder).readString(((Utf8) oldString942)); + } else { + charSequence942 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(942, charSequence942); + } else { + throw new RuntimeException(("Illegal union index for 'F942': "+ unionIndex942)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema471(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex943 = (decoder.readIndex()); + if (unionIndex943 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(943, null); + } else { + if (unionIndex943 == 1) { + Utf8 charSequence943; + Object oldString943 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(943); + if (oldString943 instanceof Utf8) { + charSequence943 = (decoder).readString(((Utf8) oldString943)); + } else { + charSequence943 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(943, charSequence943); + } else { + throw new RuntimeException(("Illegal union index for 'F943': "+ unionIndex943)); + } + } + int unionIndex944 = (decoder.readIndex()); + if (unionIndex944 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(944, null); + } else { + if (unionIndex944 == 1) { + Utf8 charSequence944; + Object oldString944 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(944); + if (oldString944 instanceof Utf8) { + charSequence944 = (decoder).readString(((Utf8) oldString944)); + } else { + charSequence944 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(944, charSequence944); + } else { + throw new RuntimeException(("Illegal union index for 'F944': "+ unionIndex944)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema472(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex945 = (decoder.readIndex()); + if (unionIndex945 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(945, null); + } else { + if (unionIndex945 == 1) { + Utf8 charSequence945; + Object oldString945 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(945); + if (oldString945 instanceof Utf8) { + charSequence945 = (decoder).readString(((Utf8) oldString945)); + } else { + charSequence945 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(945, charSequence945); + } else { + throw new RuntimeException(("Illegal union index for 'F945': "+ unionIndex945)); + } + } + int unionIndex946 = (decoder.readIndex()); + if (unionIndex946 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(946, null); + } else { + if (unionIndex946 == 1) { + Utf8 charSequence946; + Object oldString946 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(946); + if (oldString946 instanceof Utf8) { + charSequence946 = (decoder).readString(((Utf8) oldString946)); + } else { + charSequence946 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(946, charSequence946); + } else { + throw new RuntimeException(("Illegal union index for 'F946': "+ unionIndex946)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema473(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex947 = (decoder.readIndex()); + if (unionIndex947 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(947, null); + } else { + if (unionIndex947 == 1) { + Utf8 charSequence947; + Object oldString947 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(947); + if (oldString947 instanceof Utf8) { + charSequence947 = (decoder).readString(((Utf8) oldString947)); + } else { + charSequence947 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(947, charSequence947); + } else { + throw new RuntimeException(("Illegal union index for 'F947': "+ unionIndex947)); + } + } + int unionIndex948 = (decoder.readIndex()); + if (unionIndex948 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(948, null); + } else { + if (unionIndex948 == 1) { + Utf8 charSequence948; + Object oldString948 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(948); + if (oldString948 instanceof Utf8) { + charSequence948 = (decoder).readString(((Utf8) oldString948)); + } else { + charSequence948 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(948, charSequence948); + } else { + throw new RuntimeException(("Illegal union index for 'F948': "+ unionIndex948)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema474(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex949 = (decoder.readIndex()); + if (unionIndex949 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(949, null); + } else { + if (unionIndex949 == 1) { + Utf8 charSequence949; + Object oldString949 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(949); + if (oldString949 instanceof Utf8) { + charSequence949 = (decoder).readString(((Utf8) oldString949)); + } else { + charSequence949 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(949, charSequence949); + } else { + throw new RuntimeException(("Illegal union index for 'F949': "+ unionIndex949)); + } + } + int unionIndex950 = (decoder.readIndex()); + if (unionIndex950 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(950, null); + } else { + if (unionIndex950 == 1) { + Utf8 charSequence950; + Object oldString950 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(950); + if (oldString950 instanceof Utf8) { + charSequence950 = (decoder).readString(((Utf8) oldString950)); + } else { + charSequence950 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(950, charSequence950); + } else { + throw new RuntimeException(("Illegal union index for 'F950': "+ unionIndex950)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema475(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex951 = (decoder.readIndex()); + if (unionIndex951 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(951, null); + } else { + if (unionIndex951 == 1) { + Utf8 charSequence951; + Object oldString951 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(951); + if (oldString951 instanceof Utf8) { + charSequence951 = (decoder).readString(((Utf8) oldString951)); + } else { + charSequence951 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(951, charSequence951); + } else { + throw new RuntimeException(("Illegal union index for 'F951': "+ unionIndex951)); + } + } + int unionIndex952 = (decoder.readIndex()); + if (unionIndex952 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(952, null); + } else { + if (unionIndex952 == 1) { + Utf8 charSequence952; + Object oldString952 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(952); + if (oldString952 instanceof Utf8) { + charSequence952 = (decoder).readString(((Utf8) oldString952)); + } else { + charSequence952 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(952, charSequence952); + } else { + throw new RuntimeException(("Illegal union index for 'F952': "+ unionIndex952)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema476(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex953 = (decoder.readIndex()); + if (unionIndex953 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(953, null); + } else { + if (unionIndex953 == 1) { + Utf8 charSequence953; + Object oldString953 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(953); + if (oldString953 instanceof Utf8) { + charSequence953 = (decoder).readString(((Utf8) oldString953)); + } else { + charSequence953 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(953, charSequence953); + } else { + throw new RuntimeException(("Illegal union index for 'F953': "+ unionIndex953)); + } + } + int unionIndex954 = (decoder.readIndex()); + if (unionIndex954 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(954, null); + } else { + if (unionIndex954 == 1) { + Utf8 charSequence954; + Object oldString954 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(954); + if (oldString954 instanceof Utf8) { + charSequence954 = (decoder).readString(((Utf8) oldString954)); + } else { + charSequence954 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(954, charSequence954); + } else { + throw new RuntimeException(("Illegal union index for 'F954': "+ unionIndex954)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema477(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex955 = (decoder.readIndex()); + if (unionIndex955 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(955, null); + } else { + if (unionIndex955 == 1) { + Utf8 charSequence955; + Object oldString955 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(955); + if (oldString955 instanceof Utf8) { + charSequence955 = (decoder).readString(((Utf8) oldString955)); + } else { + charSequence955 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(955, charSequence955); + } else { + throw new RuntimeException(("Illegal union index for 'F955': "+ unionIndex955)); + } + } + int unionIndex956 = (decoder.readIndex()); + if (unionIndex956 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(956, null); + } else { + if (unionIndex956 == 1) { + Utf8 charSequence956; + Object oldString956 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(956); + if (oldString956 instanceof Utf8) { + charSequence956 = (decoder).readString(((Utf8) oldString956)); + } else { + charSequence956 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(956, charSequence956); + } else { + throw new RuntimeException(("Illegal union index for 'F956': "+ unionIndex956)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema478(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex957 = (decoder.readIndex()); + if (unionIndex957 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(957, null); + } else { + if (unionIndex957 == 1) { + Utf8 charSequence957; + Object oldString957 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(957); + if (oldString957 instanceof Utf8) { + charSequence957 = (decoder).readString(((Utf8) oldString957)); + } else { + charSequence957 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(957, charSequence957); + } else { + throw new RuntimeException(("Illegal union index for 'F957': "+ unionIndex957)); + } + } + int unionIndex958 = (decoder.readIndex()); + if (unionIndex958 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(958, null); + } else { + if (unionIndex958 == 1) { + Utf8 charSequence958; + Object oldString958 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(958); + if (oldString958 instanceof Utf8) { + charSequence958 = (decoder).readString(((Utf8) oldString958)); + } else { + charSequence958 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(958, charSequence958); + } else { + throw new RuntimeException(("Illegal union index for 'F958': "+ unionIndex958)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema479(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex959 = (decoder.readIndex()); + if (unionIndex959 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(959, null); + } else { + if (unionIndex959 == 1) { + Utf8 charSequence959; + Object oldString959 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(959); + if (oldString959 instanceof Utf8) { + charSequence959 = (decoder).readString(((Utf8) oldString959)); + } else { + charSequence959 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(959, charSequence959); + } else { + throw new RuntimeException(("Illegal union index for 'F959': "+ unionIndex959)); + } + } + int unionIndex960 = (decoder.readIndex()); + if (unionIndex960 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(960, null); + } else { + if (unionIndex960 == 1) { + Utf8 charSequence960; + Object oldString960 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(960); + if (oldString960 instanceof Utf8) { + charSequence960 = (decoder).readString(((Utf8) oldString960)); + } else { + charSequence960 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(960, charSequence960); + } else { + throw new RuntimeException(("Illegal union index for 'F960': "+ unionIndex960)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema480(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex961 = (decoder.readIndex()); + if (unionIndex961 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(961, null); + } else { + if (unionIndex961 == 1) { + Utf8 charSequence961; + Object oldString961 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(961); + if (oldString961 instanceof Utf8) { + charSequence961 = (decoder).readString(((Utf8) oldString961)); + } else { + charSequence961 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(961, charSequence961); + } else { + throw new RuntimeException(("Illegal union index for 'F961': "+ unionIndex961)); + } + } + int unionIndex962 = (decoder.readIndex()); + if (unionIndex962 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(962, null); + } else { + if (unionIndex962 == 1) { + Utf8 charSequence962; + Object oldString962 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(962); + if (oldString962 instanceof Utf8) { + charSequence962 = (decoder).readString(((Utf8) oldString962)); + } else { + charSequence962 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(962, charSequence962); + } else { + throw new RuntimeException(("Illegal union index for 'F962': "+ unionIndex962)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema481(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex963 = (decoder.readIndex()); + if (unionIndex963 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(963, null); + } else { + if (unionIndex963 == 1) { + Utf8 charSequence963; + Object oldString963 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(963); + if (oldString963 instanceof Utf8) { + charSequence963 = (decoder).readString(((Utf8) oldString963)); + } else { + charSequence963 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(963, charSequence963); + } else { + throw new RuntimeException(("Illegal union index for 'F963': "+ unionIndex963)); + } + } + int unionIndex964 = (decoder.readIndex()); + if (unionIndex964 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(964, null); + } else { + if (unionIndex964 == 1) { + Utf8 charSequence964; + Object oldString964 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(964); + if (oldString964 instanceof Utf8) { + charSequence964 = (decoder).readString(((Utf8) oldString964)); + } else { + charSequence964 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(964, charSequence964); + } else { + throw new RuntimeException(("Illegal union index for 'F964': "+ unionIndex964)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema482(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex965 = (decoder.readIndex()); + if (unionIndex965 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(965, null); + } else { + if (unionIndex965 == 1) { + Utf8 charSequence965; + Object oldString965 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(965); + if (oldString965 instanceof Utf8) { + charSequence965 = (decoder).readString(((Utf8) oldString965)); + } else { + charSequence965 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(965, charSequence965); + } else { + throw new RuntimeException(("Illegal union index for 'F965': "+ unionIndex965)); + } + } + int unionIndex966 = (decoder.readIndex()); + if (unionIndex966 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(966, null); + } else { + if (unionIndex966 == 1) { + Utf8 charSequence966; + Object oldString966 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(966); + if (oldString966 instanceof Utf8) { + charSequence966 = (decoder).readString(((Utf8) oldString966)); + } else { + charSequence966 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(966, charSequence966); + } else { + throw new RuntimeException(("Illegal union index for 'F966': "+ unionIndex966)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema483(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex967 = (decoder.readIndex()); + if (unionIndex967 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(967, null); + } else { + if (unionIndex967 == 1) { + Utf8 charSequence967; + Object oldString967 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(967); + if (oldString967 instanceof Utf8) { + charSequence967 = (decoder).readString(((Utf8) oldString967)); + } else { + charSequence967 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(967, charSequence967); + } else { + throw new RuntimeException(("Illegal union index for 'F967': "+ unionIndex967)); + } + } + int unionIndex968 = (decoder.readIndex()); + if (unionIndex968 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(968, null); + } else { + if (unionIndex968 == 1) { + Utf8 charSequence968; + Object oldString968 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(968); + if (oldString968 instanceof Utf8) { + charSequence968 = (decoder).readString(((Utf8) oldString968)); + } else { + charSequence968 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(968, charSequence968); + } else { + throw new RuntimeException(("Illegal union index for 'F968': "+ unionIndex968)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema484(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex969 = (decoder.readIndex()); + if (unionIndex969 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(969, null); + } else { + if (unionIndex969 == 1) { + Utf8 charSequence969; + Object oldString969 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(969); + if (oldString969 instanceof Utf8) { + charSequence969 = (decoder).readString(((Utf8) oldString969)); + } else { + charSequence969 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(969, charSequence969); + } else { + throw new RuntimeException(("Illegal union index for 'F969': "+ unionIndex969)); + } + } + int unionIndex970 = (decoder.readIndex()); + if (unionIndex970 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(970, null); + } else { + if (unionIndex970 == 1) { + Utf8 charSequence970; + Object oldString970 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(970); + if (oldString970 instanceof Utf8) { + charSequence970 = (decoder).readString(((Utf8) oldString970)); + } else { + charSequence970 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(970, charSequence970); + } else { + throw new RuntimeException(("Illegal union index for 'F970': "+ unionIndex970)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema485(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex971 = (decoder.readIndex()); + if (unionIndex971 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(971, null); + } else { + if (unionIndex971 == 1) { + Utf8 charSequence971; + Object oldString971 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(971); + if (oldString971 instanceof Utf8) { + charSequence971 = (decoder).readString(((Utf8) oldString971)); + } else { + charSequence971 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(971, charSequence971); + } else { + throw new RuntimeException(("Illegal union index for 'F971': "+ unionIndex971)); + } + } + int unionIndex972 = (decoder.readIndex()); + if (unionIndex972 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(972, null); + } else { + if (unionIndex972 == 1) { + Utf8 charSequence972; + Object oldString972 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(972); + if (oldString972 instanceof Utf8) { + charSequence972 = (decoder).readString(((Utf8) oldString972)); + } else { + charSequence972 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(972, charSequence972); + } else { + throw new RuntimeException(("Illegal union index for 'F972': "+ unionIndex972)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema486(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex973 = (decoder.readIndex()); + if (unionIndex973 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(973, null); + } else { + if (unionIndex973 == 1) { + Utf8 charSequence973; + Object oldString973 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(973); + if (oldString973 instanceof Utf8) { + charSequence973 = (decoder).readString(((Utf8) oldString973)); + } else { + charSequence973 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(973, charSequence973); + } else { + throw new RuntimeException(("Illegal union index for 'F973': "+ unionIndex973)); + } + } + int unionIndex974 = (decoder.readIndex()); + if (unionIndex974 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(974, null); + } else { + if (unionIndex974 == 1) { + Utf8 charSequence974; + Object oldString974 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(974); + if (oldString974 instanceof Utf8) { + charSequence974 = (decoder).readString(((Utf8) oldString974)); + } else { + charSequence974 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(974, charSequence974); + } else { + throw new RuntimeException(("Illegal union index for 'F974': "+ unionIndex974)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema487(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex975 = (decoder.readIndex()); + if (unionIndex975 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(975, null); + } else { + if (unionIndex975 == 1) { + Utf8 charSequence975; + Object oldString975 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(975); + if (oldString975 instanceof Utf8) { + charSequence975 = (decoder).readString(((Utf8) oldString975)); + } else { + charSequence975 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(975, charSequence975); + } else { + throw new RuntimeException(("Illegal union index for 'F975': "+ unionIndex975)); + } + } + int unionIndex976 = (decoder.readIndex()); + if (unionIndex976 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(976, null); + } else { + if (unionIndex976 == 1) { + Utf8 charSequence976; + Object oldString976 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(976); + if (oldString976 instanceof Utf8) { + charSequence976 = (decoder).readString(((Utf8) oldString976)); + } else { + charSequence976 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(976, charSequence976); + } else { + throw new RuntimeException(("Illegal union index for 'F976': "+ unionIndex976)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema488(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex977 = (decoder.readIndex()); + if (unionIndex977 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(977, null); + } else { + if (unionIndex977 == 1) { + Utf8 charSequence977; + Object oldString977 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(977); + if (oldString977 instanceof Utf8) { + charSequence977 = (decoder).readString(((Utf8) oldString977)); + } else { + charSequence977 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(977, charSequence977); + } else { + throw new RuntimeException(("Illegal union index for 'F977': "+ unionIndex977)); + } + } + int unionIndex978 = (decoder.readIndex()); + if (unionIndex978 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(978, null); + } else { + if (unionIndex978 == 1) { + Utf8 charSequence978; + Object oldString978 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(978); + if (oldString978 instanceof Utf8) { + charSequence978 = (decoder).readString(((Utf8) oldString978)); + } else { + charSequence978 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(978, charSequence978); + } else { + throw new RuntimeException(("Illegal union index for 'F978': "+ unionIndex978)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema489(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex979 = (decoder.readIndex()); + if (unionIndex979 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(979, null); + } else { + if (unionIndex979 == 1) { + Utf8 charSequence979; + Object oldString979 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(979); + if (oldString979 instanceof Utf8) { + charSequence979 = (decoder).readString(((Utf8) oldString979)); + } else { + charSequence979 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(979, charSequence979); + } else { + throw new RuntimeException(("Illegal union index for 'F979': "+ unionIndex979)); + } + } + int unionIndex980 = (decoder.readIndex()); + if (unionIndex980 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(980, null); + } else { + if (unionIndex980 == 1) { + Utf8 charSequence980; + Object oldString980 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(980); + if (oldString980 instanceof Utf8) { + charSequence980 = (decoder).readString(((Utf8) oldString980)); + } else { + charSequence980 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(980, charSequence980); + } else { + throw new RuntimeException(("Illegal union index for 'F980': "+ unionIndex980)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema490(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex981 = (decoder.readIndex()); + if (unionIndex981 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(981, null); + } else { + if (unionIndex981 == 1) { + Utf8 charSequence981; + Object oldString981 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(981); + if (oldString981 instanceof Utf8) { + charSequence981 = (decoder).readString(((Utf8) oldString981)); + } else { + charSequence981 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(981, charSequence981); + } else { + throw new RuntimeException(("Illegal union index for 'F981': "+ unionIndex981)); + } + } + int unionIndex982 = (decoder.readIndex()); + if (unionIndex982 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(982, null); + } else { + if (unionIndex982 == 1) { + Utf8 charSequence982; + Object oldString982 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(982); + if (oldString982 instanceof Utf8) { + charSequence982 = (decoder).readString(((Utf8) oldString982)); + } else { + charSequence982 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(982, charSequence982); + } else { + throw new RuntimeException(("Illegal union index for 'F982': "+ unionIndex982)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema491(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex983 = (decoder.readIndex()); + if (unionIndex983 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(983, null); + } else { + if (unionIndex983 == 1) { + Utf8 charSequence983; + Object oldString983 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(983); + if (oldString983 instanceof Utf8) { + charSequence983 = (decoder).readString(((Utf8) oldString983)); + } else { + charSequence983 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(983, charSequence983); + } else { + throw new RuntimeException(("Illegal union index for 'F983': "+ unionIndex983)); + } + } + int unionIndex984 = (decoder.readIndex()); + if (unionIndex984 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(984, null); + } else { + if (unionIndex984 == 1) { + Utf8 charSequence984; + Object oldString984 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(984); + if (oldString984 instanceof Utf8) { + charSequence984 = (decoder).readString(((Utf8) oldString984)); + } else { + charSequence984 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(984, charSequence984); + } else { + throw new RuntimeException(("Illegal union index for 'F984': "+ unionIndex984)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema492(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex985 = (decoder.readIndex()); + if (unionIndex985 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(985, null); + } else { + if (unionIndex985 == 1) { + Utf8 charSequence985; + Object oldString985 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(985); + if (oldString985 instanceof Utf8) { + charSequence985 = (decoder).readString(((Utf8) oldString985)); + } else { + charSequence985 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(985, charSequence985); + } else { + throw new RuntimeException(("Illegal union index for 'F985': "+ unionIndex985)); + } + } + int unionIndex986 = (decoder.readIndex()); + if (unionIndex986 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(986, null); + } else { + if (unionIndex986 == 1) { + Utf8 charSequence986; + Object oldString986 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(986); + if (oldString986 instanceof Utf8) { + charSequence986 = (decoder).readString(((Utf8) oldString986)); + } else { + charSequence986 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(986, charSequence986); + } else { + throw new RuntimeException(("Illegal union index for 'F986': "+ unionIndex986)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema493(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex987 = (decoder.readIndex()); + if (unionIndex987 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(987, null); + } else { + if (unionIndex987 == 1) { + Utf8 charSequence987; + Object oldString987 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(987); + if (oldString987 instanceof Utf8) { + charSequence987 = (decoder).readString(((Utf8) oldString987)); + } else { + charSequence987 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(987, charSequence987); + } else { + throw new RuntimeException(("Illegal union index for 'F987': "+ unionIndex987)); + } + } + int unionIndex988 = (decoder.readIndex()); + if (unionIndex988 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(988, null); + } else { + if (unionIndex988 == 1) { + Utf8 charSequence988; + Object oldString988 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(988); + if (oldString988 instanceof Utf8) { + charSequence988 = (decoder).readString(((Utf8) oldString988)); + } else { + charSequence988 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(988, charSequence988); + } else { + throw new RuntimeException(("Illegal union index for 'F988': "+ unionIndex988)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema494(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex989 = (decoder.readIndex()); + if (unionIndex989 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(989, null); + } else { + if (unionIndex989 == 1) { + Utf8 charSequence989; + Object oldString989 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(989); + if (oldString989 instanceof Utf8) { + charSequence989 = (decoder).readString(((Utf8) oldString989)); + } else { + charSequence989 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(989, charSequence989); + } else { + throw new RuntimeException(("Illegal union index for 'F989': "+ unionIndex989)); + } + } + int unionIndex990 = (decoder.readIndex()); + if (unionIndex990 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(990, null); + } else { + if (unionIndex990 == 1) { + Utf8 charSequence990; + Object oldString990 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(990); + if (oldString990 instanceof Utf8) { + charSequence990 = (decoder).readString(((Utf8) oldString990)); + } else { + charSequence990 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(990, charSequence990); + } else { + throw new RuntimeException(("Illegal union index for 'F990': "+ unionIndex990)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema495(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex991 = (decoder.readIndex()); + if (unionIndex991 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(991, null); + } else { + if (unionIndex991 == 1) { + Utf8 charSequence991; + Object oldString991 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(991); + if (oldString991 instanceof Utf8) { + charSequence991 = (decoder).readString(((Utf8) oldString991)); + } else { + charSequence991 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(991, charSequence991); + } else { + throw new RuntimeException(("Illegal union index for 'F991': "+ unionIndex991)); + } + } + int unionIndex992 = (decoder.readIndex()); + if (unionIndex992 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(992, null); + } else { + if (unionIndex992 == 1) { + Utf8 charSequence992; + Object oldString992 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(992); + if (oldString992 instanceof Utf8) { + charSequence992 = (decoder).readString(((Utf8) oldString992)); + } else { + charSequence992 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(992, charSequence992); + } else { + throw new RuntimeException(("Illegal union index for 'F992': "+ unionIndex992)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema496(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex993 = (decoder.readIndex()); + if (unionIndex993 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(993, null); + } else { + if (unionIndex993 == 1) { + Utf8 charSequence993; + Object oldString993 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(993); + if (oldString993 instanceof Utf8) { + charSequence993 = (decoder).readString(((Utf8) oldString993)); + } else { + charSequence993 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(993, charSequence993); + } else { + throw new RuntimeException(("Illegal union index for 'F993': "+ unionIndex993)); + } + } + int unionIndex994 = (decoder.readIndex()); + if (unionIndex994 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(994, null); + } else { + if (unionIndex994 == 1) { + Utf8 charSequence994; + Object oldString994 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(994); + if (oldString994 instanceof Utf8) { + charSequence994 = (decoder).readString(((Utf8) oldString994)); + } else { + charSequence994 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(994, charSequence994); + } else { + throw new RuntimeException(("Illegal union index for 'F994': "+ unionIndex994)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema497(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex995 = (decoder.readIndex()); + if (unionIndex995 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(995, null); + } else { + if (unionIndex995 == 1) { + Utf8 charSequence995; + Object oldString995 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(995); + if (oldString995 instanceof Utf8) { + charSequence995 = (decoder).readString(((Utf8) oldString995)); + } else { + charSequence995 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(995, charSequence995); + } else { + throw new RuntimeException(("Illegal union index for 'F995': "+ unionIndex995)); + } + } + int unionIndex996 = (decoder.readIndex()); + if (unionIndex996 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(996, null); + } else { + if (unionIndex996 == 1) { + Utf8 charSequence996; + Object oldString996 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(996); + if (oldString996 instanceof Utf8) { + charSequence996 = (decoder).readString(((Utf8) oldString996)); + } else { + charSequence996 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(996, charSequence996); + } else { + throw new RuntimeException(("Illegal union index for 'F996': "+ unionIndex996)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema498(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex997 = (decoder.readIndex()); + if (unionIndex997 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(997, null); + } else { + if (unionIndex997 == 1) { + Utf8 charSequence997; + Object oldString997 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(997); + if (oldString997 instanceof Utf8) { + charSequence997 = (decoder).readString(((Utf8) oldString997)); + } else { + charSequence997 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(997, charSequence997); + } else { + throw new RuntimeException(("Illegal union index for 'F997': "+ unionIndex997)); + } + } + int unionIndex998 = (decoder.readIndex()); + if (unionIndex998 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(998, null); + } else { + if (unionIndex998 == 1) { + Utf8 charSequence998; + Object oldString998 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(998); + if (oldString998 instanceof Utf8) { + charSequence998 = (decoder).readString(((Utf8) oldString998)); + } else { + charSequence998 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(998, charSequence998); + } else { + throw new RuntimeException(("Illegal union index for 'F998': "+ unionIndex998)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema499(IndexedRecord FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex999 = (decoder.readIndex()); + if (unionIndex999 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(999, null); + } else { + if (unionIndex999 == 1) { + Utf8 charSequence999; + Object oldString999 = FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.get(999); + if (oldString999 instanceof Utf8) { + charSequence999 = (decoder).readString(((Utf8) oldString999)); + } else { + charSequence999 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldBeAbleToReadVeryLargeSchema.put(999, charSequence999); + } else { + throw new RuntimeException(("Illegal union index for 'F999': "+ unionIndex999)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java new file mode 100644 index 000000000..c1d6fa5c9 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testString0; + private final Schema testStringUnionAlias0; + + public FastGenericDeserializerGeneratorTest_shouldReadAliasedField_GenericDeserializer_1824759546_1574596677(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testString0 = readerSchema.getField("testString").schema(); + this.testStringUnionAlias0 = readerSchema.getField("testStringUnionAlias").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadAliasedField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadAliasedField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadAliasedField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadAliasedField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadAliasedField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldReadAliasedField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'testString': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0((FastGenericDeserializerGeneratorTest_shouldReadAliasedField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadAliasedField; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadAliasedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadAliasedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(1, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadAliasedField.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadAliasedField.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnionAlias': "+ unionIndex1)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadEnumDefault_GenericDeserializer_693116719_1739184158.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadEnumDefault_GenericDeserializer_693116719_1739184158.java new file mode 100644 index 000000000..881b1aa83 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadEnumDefault_GenericDeserializer_693116719_1739184158.java @@ -0,0 +1,206 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldReadEnumDefault_GenericDeserializer_693116719_1739184158 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + private final Schema testEnumUnion0; + private final Map enumMappingtestEnum1; + private final Schema testEnumArray0; + private final Map enumMappingtestEnum2; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + private final Map enumMappingtestEnum3; + + public FastGenericDeserializerGeneratorTest_shouldReadEnumDefault_GenericDeserializer_693116719_1739184158(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(3); + tempEnumMapping0 .put(new Integer(0), new Integer(0)); + tempEnumMapping0 .put(new Integer(1), new Integer(1)); + tempEnumMapping0 .put(new Integer(2), new Integer(0)); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + HashMap tempEnumMapping1 = new HashMap(3); + tempEnumMapping1 .put(new Integer(0), new Integer(0)); + tempEnumMapping1 .put(new Integer(1), new Integer(1)); + tempEnumMapping1 .put(new Integer(2), new Integer(0)); + this.enumMappingtestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + HashMap tempEnumMapping2 = new HashMap(3); + tempEnumMapping2 .put(new Integer(0), new Integer(0)); + tempEnumMapping2 .put(new Integer(1), new Integer(1)); + tempEnumMapping2 .put(new Integer(2), new Integer(0)); + this.enumMappingtestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + HashMap tempEnumMapping3 = new HashMap(3); + tempEnumMapping3 .put(new Integer(0), new Integer(0)); + tempEnumMapping3 .put(new Integer(1), new Integer(1)); + tempEnumMapping3 .put(new Integer(2), new Integer(0)); + this.enumMappingtestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadEnumDefault0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadEnumDefault0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnumDefault; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadEnumDefault = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadEnumDefault = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadEnumDefault.put(0, enumValue0); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnumDefault0((FastGenericDeserializerGeneratorTest_shouldReadEnumDefault), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnumDefault1((FastGenericDeserializerGeneratorTest_shouldReadEnumDefault), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadEnumDefault; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnumDefault0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnumDefault, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadEnumDefault.put(1, null); + } else { + if (unionIndex0 == 1) { + int enumIndex1 = (decoder.readEnum()); + GenericEnumSymbol enumValue1 = null; + Object enumIndexLookupResult1 = enumMappingtestEnum1 .get(enumIndex1); + if (enumIndexLookupResult1 instanceof Integer) { + enumValue1 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult1))); + } else { + if (enumIndexLookupResult1 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult1); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadEnumDefault.put(1, enumValue1); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadEnumDefault.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + if (testEnumArray1 instanceof GenericArray) { + ((GenericArray) testEnumArray1).reset(); + } else { + testEnumArray1 .clear(); + } + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadEnumDefault.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + if (testEnumUnionArray1 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray1).reset(); + } else { + testEnumUnionArray1 .clear(); + } + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Schema testEnumUnion0; + private final Schema testEnumArray0; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadEnum_GenericDeserializer_695378847_695378847(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadEnum = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadEnum = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(0, new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get((decoder.readEnum())))); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadEnum1((FastGenericDeserializerGeneratorTest_shouldReadEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadEnum, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(1, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadEnum.put(1, new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get((decoder.readEnum())))); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadEnum.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + if (testEnumArray1 instanceof GenericArray) { + ((GenericArray) testEnumArray1).reset(); + } else { + testEnumArray1 .clear(); + } + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadEnum.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + if (testEnumUnionArray1 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray1).reset(); + } else { + testEnumUnionArray1 .clear(); + } + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testFixed0; + private final Schema testFixedUnion0; + private final Schema testFixedArray0; + private final Schema testFixedUnionArray0; + private final Schema testFixedUnionArrayArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadFixed_GenericDeserializer_1590965143_1590965143(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testFixed0 = readerSchema.getField("testFixed").schema(); + this.testFixedUnion0 = readerSchema.getField("testFixedUnion").schema(); + this.testFixedArray0 = readerSchema.getField("testFixedArray").schema(); + this.testFixedUnionArray0 = readerSchema.getField("testFixedUnionArray").schema(); + this.testFixedUnionArrayArrayElemSchema0 = testFixedUnionArray0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadFixed0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadFixed = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadFixed = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + byte[] testFixed1; + Object oldFixed0 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(0); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (2))) { + testFixed1 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed1 = ( new byte[2]); + } + decoder.readFixed(testFixed1); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(0, new org.apache.avro.generic.GenericData.Fixed(testFixed0, testFixed1)); + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadFixed1((FastGenericDeserializerGeneratorTest_shouldReadFixed), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadFixed; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadFixed0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadFixed, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(1, null); + } else { + if (unionIndex0 == 1) { + byte[] testFixed2; + Object oldFixed1 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(1); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (2))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[2]); + } + decoder.readFixed(testFixed2); + FastGenericDeserializerGeneratorTest_shouldReadFixed.put(1, new org.apache.avro.generic.GenericData.Fixed(testFixed0, testFixed2)); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex0)); + } + } + List testFixedArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(2); + if (oldArray0 instanceof List) { + testFixedArray1 = ((List) oldArray0); + if (testFixedArray1 instanceof GenericArray) { + ((GenericArray) testFixedArray1).reset(); + } else { + testFixedArray1 .clear(); + } + } else { + testFixedArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testFixedArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadFixed.get(3); + if (oldArray1 instanceof List) { + testFixedUnionArray1 = ((List) oldArray1); + if (testFixedUnionArray1 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray1).reset(); + } else { + testFixedUnionArray1 .clear(); + } + } else { + testFixedUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testFixedUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema union0; + private final Schema unionOptionSchema0; + private final Schema subField0; + + public FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion_GenericDeserializer_2643982_2643982(Schema readerSchema) { + this.readerSchema = readerSchema; + this.union0 = readerSchema.getField("union").schema(); + this.unionOptionSchema0 = union0 .getTypes().get(1); + this.subField0 = unionOptionSchema0 .getField("subField").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.get(0); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, charSequence1); + } else { + if (unionIndex0 == 3) { + FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + } + return FastGenericDeserializerGeneratorTest_shouldReadMultipleChoiceUnion; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == unionOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(unionOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java new file mode 100644 index 000000000..2c7c0756e --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541.java @@ -0,0 +1,129 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema mapField0; + private final Schema mapFieldMapValueSchema0; + private final Schema mapFieldValueMapValueSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadNestedMap_GenericDeserializer_1870075541_1870075541(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapField0 = readerSchema.getField("mapField").schema(); + this.mapFieldMapValueSchema0 = mapField0 .getValueType(); + this.mapFieldValueMapValueSchema0 = mapFieldMapValueSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadNestedMap0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadNestedMap; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadNestedMap = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadNestedMap = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map>> mapField1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), ((int) chunkLen0))); + } else { + Map>> mapFieldReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0); + if (oldMap0 instanceof Map) { + mapFieldReuse0 = ((Map) oldMap0); + } + if (mapFieldReuse0 != (null)) { + mapFieldReuse0 .clear(); + mapField1 = mapFieldReuse0; + } else { + mapField1 = new HashMap>>(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 > mapFieldValue0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, ((int) chunkLen1))); + } else { + Map> mapFieldValueReuse0 = null; + if (null instanceof Map) { + mapFieldValueReuse0 = ((Map) null); + } + if (mapFieldValueReuse0 != (null)) { + mapFieldValueReuse0 .clear(); + mapFieldValue0 = mapFieldValueReuse0; + } else { + mapFieldValue0 = new HashMap>(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0) { + for (int counter2 = 0; (counter2 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapFieldValue0 = ((Map)(customization).getNewMapOverrideFunc().apply(null, 0)); + } else { + mapFieldValue0 = new HashMap>(0); + } + } + mapField1 .put(key0, mapFieldValue0); + } + chunkLen0 = (decoder.mapNext()); + } while (chunkLen0 > 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapField1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadNestedMap.get(0), 0)); + } else { + mapField1 = new HashMap>>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadNestedMap.put(0, mapField1); + return FastGenericDeserializerGeneratorTest_shouldReadNestedMap; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java new file mode 100644 index 000000000..019ffe444 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208.java @@ -0,0 +1,214 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + private final Schema testEnumUnion0; + private final Map enumMappingtestEnum1; + private final Schema testEnumArray0; + private final Map enumMappingtestEnum2; + private final Schema testEnumUnionArray0; + private final Schema testEnumUnionArrayArrayElemSchema0; + private final Map enumMappingtestEnum3; + + public FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum_GenericDeserializer_611749105_646016208(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(5); + tempEnumMapping0 .put(new Integer(0), new Integer(1)); + tempEnumMapping0 .put(new Integer(1), new Integer(0)); + tempEnumMapping0 .put(new Integer(2), new Integer(4)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + this.testEnumUnion0 = readerSchema.getField("testEnumUnion").schema(); + HashMap tempEnumMapping1 = new HashMap(5); + tempEnumMapping1 .put(new Integer(0), new Integer(1)); + tempEnumMapping1 .put(new Integer(1), new Integer(0)); + tempEnumMapping1 .put(new Integer(2), new Integer(4)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + this.testEnumArray0 = readerSchema.getField("testEnumArray").schema(); + HashMap tempEnumMapping2 = new HashMap(5); + tempEnumMapping2 .put(new Integer(0), new Integer(1)); + tempEnumMapping2 .put(new Integer(1), new Integer(0)); + tempEnumMapping2 .put(new Integer(2), new Integer(4)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + this.testEnumUnionArray0 = readerSchema.getField("testEnumUnionArray").schema(); + this.testEnumUnionArrayArrayElemSchema0 = testEnumUnionArray0 .getElementType(); + HashMap tempEnumMapping3 = new HashMap(5); + tempEnumMapping3 .put(new Integer(0), new Integer(1)); + tempEnumMapping3 .put(new Integer(1), new Integer(0)); + tempEnumMapping3 .put(new Integer(2), new Integer(4)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(3)); + this.enumMappingtestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(0, enumValue0); + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum1((FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(1, null); + } else { + if (unionIndex0 == 1) { + int enumIndex1 = (decoder.readEnum()); + GenericEnumSymbol enumValue1 = null; + Object enumIndexLookupResult1 = enumMappingtestEnum1 .get(enumIndex1); + if (enumIndexLookupResult1 instanceof Integer) { + enumValue1 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult1))); + } else { + if (enumIndexLookupResult1 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult1); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.put(1, enumValue1); + } else { + throw new RuntimeException(("Illegal union index for 'testEnumUnion': "+ unionIndex0)); + } + } + List testEnumArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.get(2); + if (oldArray0 instanceof List) { + testEnumArray1 = ((List) oldArray0); + if (testEnumArray1 instanceof GenericArray) { + ((GenericArray) testEnumArray1).reset(); + } else { + testEnumArray1 .clear(); + } + } else { + testEnumArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testEnumArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testEnumUnionArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadPermutatedEnum.get(3); + if (oldArray1 instanceof List) { + testEnumUnionArray1 = ((List) oldArray1); + if (testEnumUnionArray1 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray1).reset(); + } else { + testEnumUnionArray1 .clear(); + } + } else { + testEnumUnionArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), testEnumUnionArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema testIntUnion0; + private final Schema testStringUnion0; + private final Schema testLongUnion0; + private final Schema testDoubleUnion0; + private final Schema testFloatUnion0; + private final Schema testBooleanUnion0; + private final Schema testBytesUnion0; + + public FastGenericDeserializerGeneratorTest_shouldReadPrimitives_GenericDeserializer_1966544736_1966544736(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testIntUnion0 = readerSchema.getField("testIntUnion").schema(); + this.testStringUnion0 = readerSchema.getField("testStringUnion").schema(); + this.testLongUnion0 = readerSchema.getField("testLongUnion").schema(); + this.testDoubleUnion0 = readerSchema.getField("testDoubleUnion").schema(); + this.testFloatUnion0 = readerSchema.getField("testFloatUnion").schema(); + this.testBooleanUnion0 = readerSchema.getField("testBooleanUnion").schema(); + this.testBytesUnion0 = readerSchema.getField("testBytesUnion").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadPrimitives0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(0, (decoder.readInt())); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6((FastGenericDeserializerGeneratorTest_shouldReadPrimitives), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadPrimitives; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(1, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(2); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(2, charSequence0); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(3, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(3); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(3, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex1)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(4, (decoder.readLong())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(5, null); + } else { + if (unionIndex2 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(5, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex2)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(6, (decoder.readDouble())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives3(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(7, null); + } else { + if (unionIndex3 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(7, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex3)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(8, (decoder.readFloat())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives4(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(9, null); + } else { + if (unionIndex4 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(9, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex4)); + } + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(10, (decoder.readBoolean())); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives5(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(11, null); + } else { + if (unionIndex5 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(11, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex5)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(12); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(12, byteBuffer0); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadPrimitives6(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadPrimitives, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(13, null); + } else { + if (unionIndex6 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = FastGenericDeserializerGeneratorTest_shouldReadPrimitives.get(13); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + FastGenericDeserializerGeneratorTest_shouldReadPrimitives.put(13, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex6)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java new file mode 100644 index 000000000..bec0418b0 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944.java @@ -0,0 +1,164 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema record10; + private final Schema subField0; + private final Schema intFieldField0; + private final Schema intField0; + private final Schema subField1; + private final Schema recordArray0; + + public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1274815349_1365753944(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record10 = readerSchema.getField("record1").schema(); + this.subField0 = record10 .getField("subField").schema(); + this.intFieldField0 = record10 .getField("intField").schema(); + this.intField0 = record10 .getField("intField").schema(); + this.subField1 = record10 .getField("subField").schema(); + this.recordArray0 = readerSchema.getField("recordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == record10)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(record10); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + subRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(1); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(1, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex0)); + } + } + subRecord.put(0, null); + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord1(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); + List recordArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); + if (oldArray0 instanceof List) { + recordArray1 = ((List) oldArray0); + if (recordArray1 instanceof GenericArray) { + ((GenericArray) recordArray1).reset(); + } else { + recordArray1 .clear(); + } + } else { + recordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema record10; + private final Schema subField0; + private final Schema record20; + private final Schema intField0; + private final Schema subField1; + private final Schema recordArray0; + + public FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields_GenericDeserializer_1365753944_1274815349(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record10 = readerSchema.getField("record1").schema(); + this.subField0 = record10 .getField("subField").schema(); + this.record20 = readerSchema.getField("record2").schema(); + this.intField0 = record20 .getField("intField").schema(); + this.subField1 = record20 .getField("subField").schema(); + this.recordArray0 = readerSchema.getField("recordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(0, deserializealiasedSubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0((FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields; + } + + public IndexedRecord deserializealiasedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord aliasedSubRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == record10)) { + aliasedSubRecord = ((IndexedRecord)(reuse)); + } else { + aliasedSubRecord = new org.apache.avro.generic.GenericData.Record(record10); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + decoder.readInt(); + } else { + throw new RuntimeException(("Illegal union index for 'intField': "+ unionIndex0)); + } + } + populate_aliasedSubRecord0((aliasedSubRecord), (customization), (decoder)); + return aliasedSubRecord; + } + + private void populate_aliasedSubRecord0(IndexedRecord aliasedSubRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + aliasedSubRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = aliasedSubRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + aliasedSubRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(1), (decoder), (customization))); + List recordArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSplittedAndAliasedSubRecordFields.get(2); + if (oldArray0 instanceof List) { + recordArray1 = ((List) oldArray0); + if (recordArray1 instanceof GenericArray) { + ((GenericArray) recordArray1).reset(); + } else { + recordArray1 .clear(); + } + } else { + recordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema recordsArray0; + private final Schema recordsArrayArrayElemSchema0; + private final Schema subField0; + private final Schema recordsMap0; + private final Schema recordsArrayUnion0; + private final Schema recordsArrayUnionOptionSchema0; + private final Schema recordsArrayUnionOptionArrayElemSchema0; + private final Schema recordsMapUnion0; + private final Schema recordsMapUnionOptionSchema0; + private final Schema recordsMapUnionOptionMapValueSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField_GenericDeserializer_1602399407_1602399407(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordsArray0 = readerSchema.getField("recordsArray").schema(); + this.recordsArrayArrayElemSchema0 = recordsArray0 .getElementType(); + this.subField0 = recordsArrayArrayElemSchema0 .getField("subField").schema(); + this.recordsMap0 = readerSchema.getField("recordsMap").schema(); + this.recordsArrayUnion0 = readerSchema.getField("recordsArrayUnion").schema(); + this.recordsArrayUnionOptionSchema0 = recordsArrayUnion0 .getTypes().get(1); + this.recordsArrayUnionOptionArrayElemSchema0 = recordsArrayUnionOptionSchema0 .getElementType(); + this.recordsMapUnion0 = readerSchema.getField("recordsMapUnion").schema(); + this.recordsMapUnionOptionSchema0 = recordsMapUnion0 .getTypes().get(1); + this.recordsMapUnionOptionMapValueSchema0 = recordsMapUnionOptionSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List recordsArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(0); + if (oldArray0 instanceof List) { + recordsArray1 = ((List) oldArray0); + if (recordsArray1 instanceof GenericArray) { + ((GenericArray) recordsArray1).reset(); + } else { + recordsArray1 .clear(); + } + } else { + recordsArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), recordsArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 recordsMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), ((int) chunkLen1))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap1 = recordsMapReuse0; + } else { + recordsMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(1), 0)); + } else { + recordsMap1 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(1, recordsMap1); + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(2, null); + } else { + if (unionIndex1 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(2); + if (oldArray1 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray1); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen2), recordsArrayUnionOptionSchema0); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 recordsMapUnionOption0 = null; + long chunkLen3 = (decoder.readMapStart()); + if (chunkLen3 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), ((int) chunkLen3))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); + } + } + do { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.get(3), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordCollectionsField.put(3, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex3)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java new file mode 100644 index 000000000..195f2ab8d --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481.java @@ -0,0 +1,394 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema recordsArrayMap0; + private final Schema recordsArrayMapArrayElemSchema0; + private final Schema recordsArrayMapElemMapValueSchema0; + private final Schema recordsArrayMapElemValueOptionSchema0; + private final Schema subField0; + private final Schema recordsMapArray0; + private final Schema recordsMapArrayMapValueSchema0; + private final Schema recordsMapArrayValueArrayElemSchema0; + private final Schema recordsArrayMapUnion0; + private final Schema recordsArrayMapUnionOptionArrayElemSchema0; + private final Schema recordsArrayMapUnionOptionElemMapValueSchema0; + private final Schema recordsMapArrayUnion0; + private final Schema recordsMapArrayUnionOptionSchema0; + private final Schema recordsMapArrayUnionOptionValueArrayElemSchema0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField_GenericDeserializer_624658481_624658481(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordsArrayMap0 = readerSchema.getField("recordsArrayMap").schema(); + this.recordsArrayMapArrayElemSchema0 = recordsArrayMap0 .getElementType(); + this.recordsArrayMapElemMapValueSchema0 = recordsArrayMapArrayElemSchema0 .getValueType(); + this.recordsArrayMapElemValueOptionSchema0 = recordsArrayMapElemMapValueSchema0 .getTypes().get(1); + this.subField0 = recordsArrayMapElemValueOptionSchema0 .getField("subField").schema(); + this.recordsMapArray0 = readerSchema.getField("recordsMapArray").schema(); + this.recordsMapArrayMapValueSchema0 = recordsMapArray0 .getValueType(); + this.recordsMapArrayValueArrayElemSchema0 = recordsMapArrayMapValueSchema0 .getElementType(); + this.recordsArrayMapUnion0 = readerSchema.getField("recordsArrayMapUnion").schema(); + this.recordsArrayMapUnionOptionArrayElemSchema0 = recordsArrayMap0 .getElementType(); + this.recordsArrayMapUnionOptionElemMapValueSchema0 = recordsArrayMapUnionOptionArrayElemSchema0 .getValueType(); + this.recordsMapArrayUnion0 = readerSchema.getField("recordsMapArrayUnion").schema(); + this.recordsMapArrayUnionOptionSchema0 = recordsMapArrayUnion0 .getTypes().get(1); + this.recordsMapArrayUnionOptionValueArrayElemSchema0 = recordsMapArrayMapValueSchema0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List> recordsArrayMap1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(0); + if (oldArray0 instanceof List) { + recordsArrayMap1 = ((List) oldArray0); + if (recordsArrayMap1 instanceof GenericArray) { + ((GenericArray) recordsArrayMap1).reset(); + } else { + recordsArrayMap1 .clear(); + } + } else { + recordsArrayMap1 = new org.apache.avro.generic.GenericData.Array>(((int) chunkLen0), recordsArrayMap0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 recordsArrayMapElem0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen1))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap1 .add(recordsArrayMapElem0); + } + chunkLen0 = (decoder.arrayNext()); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(0, recordsArrayMap1); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1((FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordsArrayMapElemValueOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(recordsArrayMapElemValueOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray1 = null; + long chunkLen2 = (decoder.readMapStart()); + if (chunkLen2 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), ((int) chunkLen2))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1); + if (oldMap0 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap0); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray1 = recordsMapArrayReuse0; + } else { + recordsMapArray1 = new HashMap>(((int)(((chunkLen2 * 4)+ 2)/ 3))); + } + } + do { + for (int counter2 = 0; (counter2 recordsMapArrayValue0 = null; + long chunkLen3 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen3), recordsMapArrayMapValueSchema0); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(1), 0)); + } else { + recordsMapArray1 = new HashMap>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(1, recordsMapArray1); + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(2, null); + } else { + if (unionIndex3 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(2); + if (oldArray1 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray1); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new org.apache.avro.generic.GenericData.Array>(((int) chunkLen4), recordsArrayMap0); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArrayMapUnionOptionElem0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen5))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen4 = (decoder.arrayNext()); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(2, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex3)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(3, null); + } else { + if (unionIndex5 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), ((int) chunkLen6))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3); + if (oldMap1 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 recordsMapArrayUnionOptionValue0 = null; + long chunkLen7 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen7), recordsMapArrayMapValueSchema0); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.get(3), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordComplexCollectionsField.put(3, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex5)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java new file mode 100644 index 000000000..4c47de119 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046.java @@ -0,0 +1,114 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema record0; + private final Schema recordOptionSchema0; + private final Schema subField0; + private final Schema field0; + + public FastGenericDeserializerGeneratorTest_shouldReadSubRecordField_GenericDeserializer_1111917046_1111917046(Schema readerSchema) { + this.readerSchema = readerSchema; + this.record0 = readerSchema.getField("record").schema(); + this.recordOptionSchema0 = record0 .getTypes().get(1); + this.subField0 = recordOptionSchema0 .getField("subField").schema(); + this.field0 = readerSchema.getField("field").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'record': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0((FastGenericDeserializerGeneratorTest_shouldReadSubRecordField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldReadSubRecordField; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(recordOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'subField': "+ unionIndex1)); + } + } + return subRecord; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldReadSubRecordField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldReadSubRecordField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(1), (decoder), (customization))); + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(2, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.get(2); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldReadSubRecordField.put(2, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex2)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java new file mode 100644 index 000000000..a8f3ded33 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696.java @@ -0,0 +1,256 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testNotRemoved0; + private final Schema testNotRemoved20; + private final Schema subRecord0; + private final Schema subRecordOptionSchema0; + private final Schema testNotRemoved1; + private final Schema testNotRemoved21; + private final Schema subRecordMap0; + private final Schema subRecordArray0; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedField_GenericDeserializer_1830076637_292632696(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testNotRemoved0 = readerSchema.getField("testNotRemoved").schema(); + this.testNotRemoved20 = readerSchema.getField("testNotRemoved2").schema(); + this.subRecord0 = readerSchema.getField("subRecord").schema(); + this.subRecordOptionSchema0 = subRecord0 .getTypes().get(1); + this.testNotRemoved1 = subRecordOptionSchema0 .getField("testNotRemoved").schema(); + this.testNotRemoved21 = subRecordOptionSchema0 .getField("testNotRemoved2").schema(); + this.subRecordMap0 = readerSchema.getField("subRecordMap").schema(); + this.subRecordArray0 = readerSchema.getField("subRecordArray").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex0)); + } + } + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2((FastGenericDeserializerGeneratorTest_shouldSkipRemovedField), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedField; + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + } else { + if (unionIndex1 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testRemoved': "+ unionIndex1)); + } + } + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(1, null); + } else { + if (unionIndex2 == 1) { + Utf8 charSequence1; + Object oldString1 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved2': "+ unionIndex2)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, null); + } else { + if (unionIndex3 == 1) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(2, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(2), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex3)); + } + } + Map subRecordMap1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), ((int) chunkLen0))); + } else { + Map subRecordMapReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3); + if (oldMap0 instanceof Map) { + subRecordMapReuse0 = ((Map) oldMap0); + } + if (subRecordMapReuse0 != (null)) { + subRecordMapReuse0 .clear(); + subRecordMap1 = subRecordMapReuse0; + } else { + subRecordMap1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + subRecordMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(3), 0)); + } else { + subRecordMap1 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.put(3, subRecordMap1); + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecordOptionSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecordOptionSchema0); + } + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + subRecord.put(0, null); + } else { + if (unionIndex4 == 1) { + Utf8 charSequence2; + Object oldString2 = subRecord.get(0); + if (oldString2 instanceof Utf8) { + charSequence2 = (decoder).readString(((Utf8) oldString2)); + } else { + charSequence2 = (decoder).readString(null); + } + subRecord.put(0, charSequence2); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved': "+ unionIndex4)); + } + } + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + } else { + if (unionIndex5 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'testRemoved': "+ unionIndex5)); + } + } + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + subRecord.put(1, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence3; + Object oldString3 = subRecord.get(1); + if (oldString3 instanceof Utf8) { + charSequence3 = (decoder).readString(((Utf8) oldString3)); + } else { + charSequence3 = (decoder).readString(null); + } + subRecord.put(1, charSequence3); + } else { + throw new RuntimeException(("Illegal union index for 'testNotRemoved2': "+ unionIndex6)); + } + } + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedField2(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedField, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List subRecordArray1 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldSkipRemovedField.get(4); + if (oldArray0 instanceof List) { + subRecordArray1 = ((List) oldArray0); + if (subRecordArray1 instanceof GenericArray) { + ((GenericArray) subRecordArray1).reset(); + } else { + subRecordArray1 .clear(); + } + } else { + subRecordArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen1), subRecordArray0); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 +{ + + private final Schema readerSchema; + private final Schema subRecord0; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord_GenericDeserializer_1090641932_438987109(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord.get(0), (decoder), (customization))); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedNestedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord0); + } + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + populate_subRecord0((subRecord), (customization), (decoder)); + populate_subRecord1((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubSubRecord0(null, (decoder), (customization)); + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + deserializesubSubRecord0(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'test3': "+ unionIndex0)); + } + } + } + + public void deserializesubSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + populate_subSubRecord0((decoder)); + } + + private void populate_subSubRecord0(Decoder decoder) + throws IOException + { + decoder.skipString(); + } + + private void populate_subRecord1(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = subRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + subRecord.put(1, charSequence1); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java new file mode 100644 index 000000000..8c7c9f8b7 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291.java @@ -0,0 +1,114 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema subRecord10; + + public FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord_GenericDeserializer_1932590611_1452595291(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord10 = readerSchema.getField("subRecord1").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(0, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(0), (decoder), (customization))); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1((FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord), (customization), (decoder)); + return FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord10)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord10); + } + Utf8 charSequence0; + Object oldString0 = subRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + subRecord.put(0, charSequence0); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Utf8 charSequence1; + Object oldString1 = subRecord.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + subRecord.put(1, charSequence1); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord0(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializesubRecord20(null, (decoder), (customization)); + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + } else { + if (unionIndex0 == 1) { + deserializesubRecord20(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord3': "+ unionIndex0)); + } + } + } + + public void deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + populate_subRecord20((decoder)); + } + + private void populate_subRecord20(Decoder decoder) + throws IOException + { + decoder.skipString(); + } + + private void populate_FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord1(IndexedRecord FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.put(1, deserializesubRecord0(FastGenericDeserializerGeneratorTest_shouldSkipRemovedRecord.get(1), (decoder), (customization))); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java new file mode 100644 index 000000000..33f5bbe55 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769.java @@ -0,0 +1,60 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_1186244769(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java new file mode 100644 index 000000000..affba44e1 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918.java @@ -0,0 +1,60 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_1186244769_367446918(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java new file mode 100644 index 000000000..1e3750cc5 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_1186244769(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + throw new AvroTypeException("Found \"long\", expecting [\"null\", \"string\"]"); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java new file mode 100644 index 000000000..56b68dd25 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType_GenericDeserializer_367446918_367446918(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType.put(0, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateOrFailLikeVanillaAvroWhenTheReaderUnionIsMissingAType; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java new file mode 100644 index 000000000..015cb3698 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_1986844009(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java new file mode 100644 index 000000000..8201351b2 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_1986844009_611693319(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java new file mode 100644 index 000000000..74b8e4040 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_1986844009(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java new file mode 100644 index 000000000..db79467b9 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319.java @@ -0,0 +1,64 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString_GenericDeserializer_611693319_611693319(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + Utf8 charSequence0; + Object oldString0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingThatIncludeString; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java new file mode 100644 index 000000000..79727d899 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273.java @@ -0,0 +1,71 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_1778260273(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_1778260273_906204958(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_1778260273(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.put(0, null); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays_GenericDeserializer_906204958_906204958(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.put(0, null); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList testOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithArrays.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + testOption0 = ((PrimitiveIntList) oldArray0); + testOption0 .clear(); + } else { + testOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_2127585735(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + if (unionIndex0 == 1) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java new file mode 100644 index 000000000..052f96d1d --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_2127585735_539246803(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + if (unionIndex0 == 1) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java new file mode 100644 index 000000000..0b8b2d24f --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_2127585735(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + if (unionIndex0 == 1) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java new file mode 100644 index 000000000..65f285d75 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803.java @@ -0,0 +1,89 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps_GenericDeserializer_539246803_539246803(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, null); + } else { + if (unionIndex0 == 1) { + Map testOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), ((int) chunkLen0))); + } else { + Map testOptionReuse0 = null; + Object oldMap0 = FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0); + if (oldMap0 instanceof Map) { + testOptionReuse0 = ((Map) oldMap0); + } + if (testOptionReuse0 != (null)) { + testOptionReuse0 .clear(); + testOption0 = testOptionReuse0; + } else { + testOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.get(0), 0)); + } else { + testOption0 = new HashMap(0); + } + } + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps.put(0, testOption0); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithMaps; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java new file mode 100644 index 000000000..5a8c27b89 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_1284646643(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java new file mode 100644 index 000000000..5bb43d8dc --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_1284646643_616931169(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java new file mode 100644 index 000000000..73ce9109f --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_1284646643(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java new file mode 100644 index 000000000..44aaccac1 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString_GenericDeserializer_616931169_616931169(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString.put(0, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithNonString; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java new file mode 100644 index 000000000..8b82d4942 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_524692447(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + this.testOptionSchema1 = test0 .getTypes().get(2); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java new file mode 100644 index 000000000..9110d28c1 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_524692447_963368136(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(1); + this.testOptionSchema1 = test0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java new file mode 100644 index 000000000..49a494b2e --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_524692447(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(2); + this.testOptionSchema1 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java new file mode 100644 index 000000000..6db440522 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136.java @@ -0,0 +1,86 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema test0; + private final Schema testOptionSchema0; + private final Schema testOptionSchema1; + + public FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords_GenericDeserializer_963368136_963368136(Schema readerSchema) { + this.readerSchema = readerSchema; + this.test0 = readerSchema.getField("test").schema(); + this.testOptionSchema0 = test0 .getTypes().get(0); + this.testOptionSchema1 = test0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = ((IndexedRecord)(reuse)); + } else { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord20(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, deserializesubRecord10(FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 2) { + decoder.readNull(); + FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords.put(0, null); + } else { + throw new RuntimeException(("Illegal union index for 'test': "+ unionIndex0)); + } + } + } + return FastGenericDeserializerGeneratorTest_shouldTolerateUnionReorderingWithSubRecords; + } + + public IndexedRecord deserializesubRecord20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord2; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema0)) { + subRecord2 = ((IndexedRecord)(reuse)); + } else { + subRecord2 = new org.apache.avro.generic.GenericData.Record(testOptionSchema0); + } + subRecord2 .put(0, (decoder.readInt())); + return subRecord2; + } + + public IndexedRecord deserializesubRecord10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == testOptionSchema1)) { + subRecord1 = ((IndexedRecord)(reuse)); + } else { + subRecord1 = new org.apache.avro.generic.GenericData.Record(testOptionSchema1); + } + subRecord1 .put(0, (decoder.readInt())); + return subRecord1; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastSerdeLogicalTypesDefined_GenericDeserializer_229156053_229156053.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastSerdeLogicalTypesDefined_GenericDeserializer_229156053_229156053.java new file mode 100644 index 000000000..57b1189f1 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastSerdeLogicalTypesDefined_GenericDeserializer_229156053_229156053.java @@ -0,0 +1,111 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.time.Instant; +import java.time.LocalDate; +import java.time.LocalTime; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Conversions; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastSerdeLogicalTypesDefined_GenericDeserializer_229156053_229156053 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final Conversions.DecimalConversion conversion_decimal = new Conversions.DecimalConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema timeMillisField0; + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema dateField0; + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema arrayOfUnionOfDateAndTimestampMillis0; + private final Schema arrayOfUnionOfDateAndTimestampMillisArrayElemSchema0; + private final Schema arrayOfUnionOfDateAndTimestampMillisElemOptionSchema0; + private final Schema arrayOfUnionOfDateAndTimestampMillisElemOptionSchema1; + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + + public FastSerdeLogicalTypesDefined_GenericDeserializer_229156053_229156053(Schema readerSchema) { + this.readerSchema = readerSchema; + this.timeMillisField0 = readerSchema.getField("timeMillisField").schema(); + this.dateField0 = readerSchema.getField("dateField").schema(); + this.arrayOfUnionOfDateAndTimestampMillis0 = readerSchema.getField("arrayOfUnionOfDateAndTimestampMillis").schema(); + this.arrayOfUnionOfDateAndTimestampMillisArrayElemSchema0 = arrayOfUnionOfDateAndTimestampMillis0 .getElementType(); + this.arrayOfUnionOfDateAndTimestampMillisElemOptionSchema0 = arrayOfUnionOfDateAndTimestampMillisArrayElemSchema0 .getTypes().get(0); + this.arrayOfUnionOfDateAndTimestampMillisElemOptionSchema1 = arrayOfUnionOfDateAndTimestampMillisArrayElemSchema0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesDefined0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastSerdeLogicalTypesDefined0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastSerdeLogicalTypesDefined; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastSerdeLogicalTypesDefined = ((IndexedRecord)(reuse)); + } else { + FastSerdeLogicalTypesDefined = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + LocalTime convertedValue0 = ((LocalTime) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis)); + FastSerdeLogicalTypesDefined.put(0, convertedValue0); + populate_FastSerdeLogicalTypesDefined0((FastSerdeLogicalTypesDefined), (customization), (decoder)); + return FastSerdeLogicalTypesDefined; + } + + private void populate_FastSerdeLogicalTypesDefined0(IndexedRecord FastSerdeLogicalTypesDefined, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + LocalDate convertedValue1 = ((LocalDate) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date)); + FastSerdeLogicalTypesDefined.put(1, convertedValue1); + List arrayOfUnionOfDateAndTimestampMillis1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastSerdeLogicalTypesDefined.get(2); + if (oldArray0 instanceof List) { + arrayOfUnionOfDateAndTimestampMillis1 = ((List) oldArray0); + if (arrayOfUnionOfDateAndTimestampMillis1 instanceof GenericArray) { + ((GenericArray) arrayOfUnionOfDateAndTimestampMillis1).reset(); + } else { + arrayOfUnionOfDateAndTimestampMillis1 .clear(); + } + } else { + arrayOfUnionOfDateAndTimestampMillis1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), arrayOfUnionOfDateAndTimestampMillis0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final Conversions.DecimalConversion conversion_decimal = new Conversions.DecimalConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + + public FastSerdeLogicalTypesDefined_SpecificDeserializer_229156053_229156053(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined deserialize(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesDefined0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined deserializeFastSerdeLogicalTypesDefined0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined FastSerdeLogicalTypesDefined; + if ((reuse)!= null) { + FastSerdeLogicalTypesDefined = ((com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined)(reuse)); + } else { + FastSerdeLogicalTypesDefined = new com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined(); + } + LocalTime convertedValue0 = ((LocalTime) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis)); + FastSerdeLogicalTypesDefined.put(0, convertedValue0); + populate_FastSerdeLogicalTypesDefined0((FastSerdeLogicalTypesDefined), (customization), (decoder)); + return FastSerdeLogicalTypesDefined; + } + + private void populate_FastSerdeLogicalTypesDefined0(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined FastSerdeLogicalTypesDefined, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + LocalDate convertedValue1 = ((LocalDate) Conversions.convertToLogicalType((decoder.readInt()), this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date)); + FastSerdeLogicalTypesDefined.put(1, convertedValue1); + List arrayOfUnionOfDateAndTimestampMillis0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastSerdeLogicalTypesDefined.get(2); + if (oldArray0 instanceof List) { + arrayOfUnionOfDateAndTimestampMillis0 = ((List) oldArray0); + if (arrayOfUnionOfDateAndTimestampMillis0 instanceof GenericArray) { + ((GenericArray) arrayOfUnionOfDateAndTimestampMillis0).reset(); + } else { + arrayOfUnionOfDateAndTimestampMillis0 .clear(); + } + } else { + arrayOfUnionOfDateAndTimestampMillis0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final Conversions.DecimalConversion conversion_decimal = new Conversions.DecimalConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema unionOfArrayAndMap0; + private final Schema unionOfArrayAndMapOptionSchema0; + private final Schema unionOfArrayAndMapOptionArrayElemSchema0; + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema unionOfArrayAndMapOptionSchema1; + private final Schema unionOfArrayAndMapOptionMapValueSchema0; + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema mapOfUnionsOfDateAndTimestampMillis0; + private final Schema mapOfUnionsOfDateAndTimestampMillisMapValueSchema0; + private final Schema mapOfUnionsOfDateAndTimestampMillisValueOptionSchema0; + private final Schema mapOfUnionsOfDateAndTimestampMillisValueOptionSchema1; + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + private final Schema timestampMillisMap0; + private final Schema timestampMillisMapMapValueSchema0; + private final Schema nullableArrayOfDates0; + private final Schema nullableArrayOfDatesOptionSchema0; + private final Schema nullableArrayOfDatesOptionArrayElemSchema0; + private final Schema arrayOfDatesArrayElemSchema0; + private final Schema unionOfDecimalOrDate0; + private final Schema unionOfDecimalOrDateOptionSchema0; + private final Schema logicalTypeSchema_120893213 = Schema.parse("{\"type\":\"bytes\",\"logicalType\":\"decimal\",\"precision\":4,\"scale\":2}"); + private final Schema unionOfDecimalOrDateOptionSchema1; + private final Schema timestampMillisField0; + private final Schema timestampMicrosField0; + private final Schema logicalTypeSchema__1252781617 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-micros\"}"); + private final Schema timeMillisField0; + private final Schema timeMicrosField0; + private final Schema logicalTypeSchema__1515894331 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"time-micros\"}"); + private final Schema dateField0; + private final Schema nestedLocalTimestampMillis0; + private final Schema nullableNestedTimestamp0; + private final Schema nullableUnionOfDateAndLocalTimestamp0; + private final Schema nullableUnionOfDateAndLocalTimestampOptionSchema0; + private final Schema unionOfDateAndLocalTimestamp0; + private final Schema unionOfDateAndLocalTimestampOptionSchema0; + + public FastSerdeLogicalTypesTest1_GenericDeserializer_1007574890_1007574890(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOfArrayAndMap0 = readerSchema.getField("unionOfArrayAndMap").schema(); + this.unionOfArrayAndMapOptionSchema0 = unionOfArrayAndMap0 .getTypes().get(0); + this.unionOfArrayAndMapOptionArrayElemSchema0 = unionOfArrayAndMapOptionSchema0 .getElementType(); + this.unionOfArrayAndMapOptionSchema1 = unionOfArrayAndMap0 .getTypes().get(1); + this.unionOfArrayAndMapOptionMapValueSchema0 = unionOfArrayAndMapOptionSchema1 .getValueType(); + this.mapOfUnionsOfDateAndTimestampMillis0 = readerSchema.getField("mapOfUnionsOfDateAndTimestampMillis").schema(); + this.mapOfUnionsOfDateAndTimestampMillisMapValueSchema0 = mapOfUnionsOfDateAndTimestampMillis0 .getValueType(); + this.mapOfUnionsOfDateAndTimestampMillisValueOptionSchema0 = mapOfUnionsOfDateAndTimestampMillisMapValueSchema0 .getTypes().get(0); + this.mapOfUnionsOfDateAndTimestampMillisValueOptionSchema1 = mapOfUnionsOfDateAndTimestampMillisMapValueSchema0 .getTypes().get(1); + this.timestampMillisMap0 = readerSchema.getField("timestampMillisMap").schema(); + this.timestampMillisMapMapValueSchema0 = timestampMillisMap0 .getValueType(); + this.nullableArrayOfDates0 = readerSchema.getField("nullableArrayOfDates").schema(); + this.nullableArrayOfDatesOptionSchema0 = nullableArrayOfDates0 .getTypes().get(1); + this.nullableArrayOfDatesOptionArrayElemSchema0 = nullableArrayOfDatesOptionSchema0 .getElementType(); + this.arrayOfDatesArrayElemSchema0 = nullableArrayOfDatesOptionSchema0 .getElementType(); + this.unionOfDecimalOrDate0 = readerSchema.getField("unionOfDecimalOrDate").schema(); + this.unionOfDecimalOrDateOptionSchema0 = unionOfDecimalOrDate0 .getTypes().get(0); + this.unionOfDecimalOrDateOptionSchema1 = unionOfDecimalOrDate0 .getTypes().get(1); + this.timestampMillisField0 = readerSchema.getField("timestampMillisField").schema(); + this.timestampMicrosField0 = readerSchema.getField("timestampMicrosField").schema(); + this.timeMillisField0 = readerSchema.getField("timeMillisField").schema(); + this.timeMicrosField0 = readerSchema.getField("timeMicrosField").schema(); + this.dateField0 = readerSchema.getField("dateField").schema(); + this.nestedLocalTimestampMillis0 = readerSchema.getField("nestedLocalTimestampMillis").schema(); + this.nullableNestedTimestamp0 = nestedLocalTimestampMillis0 .getField("nullableNestedTimestamp").schema(); + this.nullableUnionOfDateAndLocalTimestamp0 = nestedLocalTimestampMillis0 .getField("nullableUnionOfDateAndLocalTimestamp").schema(); + this.nullableUnionOfDateAndLocalTimestampOptionSchema0 = nullableUnionOfDateAndLocalTimestamp0 .getTypes().get(1); + this.unionOfDateAndLocalTimestamp0 = nestedLocalTimestampMillis0 .getField("unionOfDateAndLocalTimestamp").schema(); + this.unionOfDateAndLocalTimestampOptionSchema0 = unionOfDateAndLocalTimestamp0 .getTypes().get(0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesTest10((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastSerdeLogicalTypesTest10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastSerdeLogicalTypesTest1; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastSerdeLogicalTypesTest1 = ((IndexedRecord)(reuse)); + } else { + FastSerdeLogicalTypesTest1 = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + List unionOfArrayAndMapOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastSerdeLogicalTypesTest1 .get(0); + if (oldArray0 instanceof List) { + unionOfArrayAndMapOption0 = ((List) oldArray0); + unionOfArrayAndMapOption0 .clear(); + } else { + unionOfArrayAndMapOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), unionOfArrayAndMapOptionSchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 unionOfArrayAndMapOption1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOfArrayAndMapOption1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(0), ((int) chunkLen1))); + } else { + Map unionOfArrayAndMapOptionReuse0 = null; + Object oldMap0 = FastSerdeLogicalTypesTest1 .get(0); + if (oldMap0 instanceof Map) { + unionOfArrayAndMapOptionReuse0 = ((Map) oldMap0); + } + if (unionOfArrayAndMapOptionReuse0 != (null)) { + unionOfArrayAndMapOptionReuse0 .clear(); + unionOfArrayAndMapOption1 = unionOfArrayAndMapOptionReuse0; + } else { + unionOfArrayAndMapOption1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOfArrayAndMapOption1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(0), 0)); + } else { + unionOfArrayAndMapOption1 = new HashMap(0); + } + } + FastSerdeLogicalTypesTest1 .put(0, unionOfArrayAndMapOption1); + } else { + throw new RuntimeException(("Illegal union index for 'unionOfArrayAndMap': "+ unionIndex0)); + } + } + populate_FastSerdeLogicalTypesTest10((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest11((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest12((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest13((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest14((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest15((FastSerdeLogicalTypesTest1), (customization), (decoder)); + return FastSerdeLogicalTypesTest1; + } + + private void populate_FastSerdeLogicalTypesTest10(IndexedRecord FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map mapOfUnionsOfDateAndTimestampMillis1 = null; + long chunkLen2 = (decoder.readMapStart()); + if (chunkLen2 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapOfUnionsOfDateAndTimestampMillis1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(1), ((int) chunkLen2))); + } else { + Map mapOfUnionsOfDateAndTimestampMillisReuse0 = null; + Object oldMap1 = FastSerdeLogicalTypesTest1 .get(1); + if (oldMap1 instanceof Map) { + mapOfUnionsOfDateAndTimestampMillisReuse0 = ((Map) oldMap1); + } + if (mapOfUnionsOfDateAndTimestampMillisReuse0 != (null)) { + mapOfUnionsOfDateAndTimestampMillisReuse0 .clear(); + mapOfUnionsOfDateAndTimestampMillis1 = mapOfUnionsOfDateAndTimestampMillisReuse0; + } else { + mapOfUnionsOfDateAndTimestampMillis1 = new HashMap(((int)(((chunkLen2 * 4)+ 2)/ 3))); + } + } + do { + for (int counter2 = 0; (counter2 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapOfUnionsOfDateAndTimestampMillis1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(1), 0)); + } else { + mapOfUnionsOfDateAndTimestampMillis1 = new HashMap(0); + } + } + FastSerdeLogicalTypesTest1 .put(1, mapOfUnionsOfDateAndTimestampMillis1); + Map timestampMillisMap1 = null; + long chunkLen3 = (decoder.readMapStart()); + if (chunkLen3 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + timestampMillisMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(2), ((int) chunkLen3))); + } else { + Map timestampMillisMapReuse0 = null; + Object oldMap2 = FastSerdeLogicalTypesTest1 .get(2); + if (oldMap2 instanceof Map) { + timestampMillisMapReuse0 = ((Map) oldMap2); + } + if (timestampMillisMapReuse0 != (null)) { + timestampMillisMapReuse0 .clear(); + timestampMillisMap1 = timestampMillisMapReuse0; + } else { + timestampMillisMap1 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); + } + } + do { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + timestampMillisMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(2), 0)); + } else { + timestampMillisMap1 = new HashMap(0); + } + } + FastSerdeLogicalTypesTest1 .put(2, timestampMillisMap1); + } + + private void populate_FastSerdeLogicalTypesTest11(IndexedRecord FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastSerdeLogicalTypesTest1 .put(3, null); + } else { + if (unionIndex2 == 1) { + List nullableArrayOfDatesOption0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray1 = FastSerdeLogicalTypesTest1 .get(3); + if (oldArray1 instanceof List) { + nullableArrayOfDatesOption0 = ((List) oldArray1); + nullableArrayOfDatesOption0 .clear(); + } else { + nullableArrayOfDatesOption0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen4), nullableArrayOfDatesOptionSchema0); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 arrayOfDates0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray2 = FastSerdeLogicalTypesTest1 .get(4); + if (oldArray2 instanceof List) { + arrayOfDates0 = ((List) oldArray2); + arrayOfDates0 .clear(); + } else { + arrayOfDates0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen5), nullableArrayOfDatesOptionSchema0); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 +{ + + private final Schema readerSchema; + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final Conversions.DecimalConversion conversion_decimal = new Conversions.DecimalConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + private final Schema logicalTypeSchema_120893213 = Schema.parse("{\"type\":\"bytes\",\"logicalType\":\"decimal\",\"precision\":4,\"scale\":2}"); + private final Schema logicalTypeSchema__1252781617 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-micros\"}"); + private final Schema logicalTypeSchema__1515894331 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"time-micros\"}"); + + public FastSerdeLogicalTypesTest1_SpecificDeserializer_1007574890_1007574890(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 deserialize(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesTest10((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 deserializeFastSerdeLogicalTypesTest10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1; + if ((reuse)!= null) { + FastSerdeLogicalTypesTest1 = ((com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1)(reuse)); + } else { + FastSerdeLogicalTypesTest1 = new com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + List unionOfArrayAndMapOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastSerdeLogicalTypesTest1 .get(0); + if (oldArray0 instanceof List) { + unionOfArrayAndMapOption0 = ((List) oldArray0); + unionOfArrayAndMapOption0 .clear(); + } else { + unionOfArrayAndMapOption0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 unionOfArrayAndMapOption1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOfArrayAndMapOption1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(0), ((int) chunkLen1))); + } else { + Map unionOfArrayAndMapOptionReuse0 = null; + Object oldMap0 = FastSerdeLogicalTypesTest1 .get(0); + if (oldMap0 instanceof Map) { + unionOfArrayAndMapOptionReuse0 = ((Map) oldMap0); + } + if (unionOfArrayAndMapOptionReuse0 != (null)) { + unionOfArrayAndMapOptionReuse0 .clear(); + unionOfArrayAndMapOption1 = unionOfArrayAndMapOptionReuse0; + } else { + unionOfArrayAndMapOption1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOfArrayAndMapOption1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(0), 0)); + } else { + unionOfArrayAndMapOption1 = new HashMap(0); + } + } + FastSerdeLogicalTypesTest1 .put(0, unionOfArrayAndMapOption1); + } else { + throw new RuntimeException(("Illegal union index for 'unionOfArrayAndMap': "+ unionIndex0)); + } + } + populate_FastSerdeLogicalTypesTest10((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest11((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest12((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest13((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest14((FastSerdeLogicalTypesTest1), (customization), (decoder)); + populate_FastSerdeLogicalTypesTest15((FastSerdeLogicalTypesTest1), (customization), (decoder)); + return FastSerdeLogicalTypesTest1; + } + + private void populate_FastSerdeLogicalTypesTest10(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map mapOfUnionsOfDateAndTimestampMillis0 = null; + long chunkLen2 = (decoder.readMapStart()); + if (chunkLen2 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapOfUnionsOfDateAndTimestampMillis0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(1), ((int) chunkLen2))); + } else { + Map mapOfUnionsOfDateAndTimestampMillisReuse0 = null; + Object oldMap1 = FastSerdeLogicalTypesTest1 .get(1); + if (oldMap1 instanceof Map) { + mapOfUnionsOfDateAndTimestampMillisReuse0 = ((Map) oldMap1); + } + if (mapOfUnionsOfDateAndTimestampMillisReuse0 != (null)) { + mapOfUnionsOfDateAndTimestampMillisReuse0 .clear(); + mapOfUnionsOfDateAndTimestampMillis0 = mapOfUnionsOfDateAndTimestampMillisReuse0; + } else { + mapOfUnionsOfDateAndTimestampMillis0 = new HashMap(((int)(((chunkLen2 * 4)+ 2)/ 3))); + } + } + do { + for (int counter2 = 0; (counter2 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + mapOfUnionsOfDateAndTimestampMillis0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(1), 0)); + } else { + mapOfUnionsOfDateAndTimestampMillis0 = new HashMap(0); + } + } + FastSerdeLogicalTypesTest1 .put(1, mapOfUnionsOfDateAndTimestampMillis0); + Map timestampMillisMap0 = null; + long chunkLen3 = (decoder.readMapStart()); + if (chunkLen3 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + timestampMillisMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(2), ((int) chunkLen3))); + } else { + Map timestampMillisMapReuse0 = null; + Object oldMap2 = FastSerdeLogicalTypesTest1 .get(2); + if (oldMap2 instanceof Map) { + timestampMillisMapReuse0 = ((Map) oldMap2); + } + if (timestampMillisMapReuse0 != (null)) { + timestampMillisMapReuse0 .clear(); + timestampMillisMap0 = timestampMillisMapReuse0; + } else { + timestampMillisMap0 = new HashMap(((int)(((chunkLen3 * 4)+ 2)/ 3))); + } + } + do { + for (int counter3 = 0; (counter3 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + timestampMillisMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(FastSerdeLogicalTypesTest1 .get(2), 0)); + } else { + timestampMillisMap0 = new HashMap(0); + } + } + FastSerdeLogicalTypesTest1 .put(2, timestampMillisMap0); + } + + private void populate_FastSerdeLogicalTypesTest11(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesTest1 FastSerdeLogicalTypesTest1, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + FastSerdeLogicalTypesTest1 .put(3, null); + } else { + if (unionIndex2 == 1) { + List nullableArrayOfDatesOption0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray1 = FastSerdeLogicalTypesTest1 .get(3); + if (oldArray1 instanceof List) { + nullableArrayOfDatesOption0 = ((List) oldArray1); + nullableArrayOfDatesOption0 .clear(); + } else { + nullableArrayOfDatesOption0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 arrayOfDates0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray2 = FastSerdeLogicalTypesTest1 .get(4); + if (oldArray2 instanceof List) { + arrayOfDates0 = ((List) oldArray2); + arrayOfDates0 .clear(); + } else { + arrayOfDates0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 +{ + + private final Schema readerSchema; + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.Conversions.DecimalConversion conversion_decimal = new org.apache.avro.Conversions.DecimalConversion(); + private final Schema arrayOfUnionOfDateAndTimestampMillis0; + private final Schema arrayOfUnionOfDateAndTimestampMillisArrayElemSchema0; + + public FastSerdeLogicalTypesUndefined_GenericDeserializer_1982763418_1982763418(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayOfUnionOfDateAndTimestampMillis0 = readerSchema.getField("arrayOfUnionOfDateAndTimestampMillis").schema(); + this.arrayOfUnionOfDateAndTimestampMillisArrayElemSchema0 = arrayOfUnionOfDateAndTimestampMillis0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesUndefined0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastSerdeLogicalTypesUndefined0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastSerdeLogicalTypesUndefined; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastSerdeLogicalTypesUndefined = ((IndexedRecord)(reuse)); + } else { + FastSerdeLogicalTypesUndefined = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + FastSerdeLogicalTypesUndefined.put(0, (decoder.readInt())); + populate_FastSerdeLogicalTypesUndefined0((FastSerdeLogicalTypesUndefined), (customization), (decoder)); + return FastSerdeLogicalTypesUndefined; + } + + private void populate_FastSerdeLogicalTypesUndefined0(IndexedRecord FastSerdeLogicalTypesUndefined, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastSerdeLogicalTypesUndefined.put(1, (decoder.readInt())); + List arrayOfUnionOfDateAndTimestampMillis1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastSerdeLogicalTypesUndefined.get(2); + if (oldArray0 instanceof List) { + arrayOfUnionOfDateAndTimestampMillis1 = ((List) oldArray0); + if (arrayOfUnionOfDateAndTimestampMillis1 instanceof GenericArray) { + ((GenericArray) arrayOfUnionOfDateAndTimestampMillis1).reset(); + } else { + arrayOfUnionOfDateAndTimestampMillis1 .clear(); + } + } else { + arrayOfUnionOfDateAndTimestampMillis1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), arrayOfUnionOfDateAndTimestampMillis0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.Conversions.DecimalConversion conversion_decimal = new org.apache.avro.Conversions.DecimalConversion(); + + public FastSerdeLogicalTypesUndefined_SpecificDeserializer_1982763418_1982763418(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined deserialize(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastSerdeLogicalTypesUndefined0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined deserializeFastSerdeLogicalTypesUndefined0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined FastSerdeLogicalTypesUndefined; + if ((reuse)!= null) { + FastSerdeLogicalTypesUndefined = ((com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined)(reuse)); + } else { + FastSerdeLogicalTypesUndefined = new com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined(); + } + FastSerdeLogicalTypesUndefined.put(0, (decoder.readInt())); + populate_FastSerdeLogicalTypesUndefined0((FastSerdeLogicalTypesUndefined), (customization), (decoder)); + return FastSerdeLogicalTypesUndefined; + } + + private void populate_FastSerdeLogicalTypesUndefined0(com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined FastSerdeLogicalTypesUndefined, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + FastSerdeLogicalTypesUndefined.put(1, (decoder.readInt())); + List arrayOfUnionOfDateAndTimestampMillis0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastSerdeLogicalTypesUndefined.get(2); + if (oldArray0 instanceof List) { + arrayOfUnionOfDateAndTimestampMillis0 = ((List) oldArray0); + if (arrayOfUnionOfDateAndTimestampMillis0 instanceof GenericArray) { + ((GenericArray) arrayOfUnionOfDateAndTimestampMillis0).reset(); + } else { + arrayOfUnionOfDateAndTimestampMillis0 .clear(); + } + } else { + arrayOfUnionOfDateAndTimestampMillis0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_205569(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyInReaderSchemaTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyInReaderSchemaTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence1; + Object oldString1 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(1); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + if (testStringArray1 instanceof GenericArray) { + ((GenericArray) testStringArray1).reset(); + } else { + testStringArray1 .clear(); + } + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java new file mode 100644 index 000000000..ad1a924d2 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558.java @@ -0,0 +1,134 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericDeserializer_205569_941602558(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyInReaderSchemaTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyInReaderSchemaTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + String charSequence0 = (decoder).readString(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyInReaderSchemaTest1((FastStringableTest_javaStringPropertyInReaderSchemaTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyInReaderSchemaTest; + } + + private void populate_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord FastStringableTest_javaStringPropertyInReaderSchemaTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, null); + } else { + if (unionIndex0 == 1) { + String charSequence1 = (decoder).readString(); + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + if (testStringArray1 instanceof GenericArray) { + ((GenericArray) testStringArray1).reset(); + } else { + testStringArray1 .clear(); + } + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyInReaderSchemaTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyInReaderSchemaTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java new file mode 100644 index 000000000..4086e7fbc --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985.java @@ -0,0 +1,134 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema testUnionString0; + private final Schema testStringArray0; + private final Schema testStringMap0; + + public FastStringableTest_javaStringPropertyTest_GenericDeserializer_1110978985_1110978985(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testUnionString0 = readerSchema.getField("testUnionString").schema(); + this.testStringArray0 = readerSchema.getField("testStringArray").schema(); + this.testStringMap0 = readerSchema.getField("testStringMap").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeFastStringableTest_javaStringPropertyTest0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeFastStringableTest_javaStringPropertyTest0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord FastStringableTest_javaStringPropertyTest; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + FastStringableTest_javaStringPropertyTest = ((IndexedRecord)(reuse)); + } else { + FastStringableTest_javaStringPropertyTest = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + String charSequence0 = (decoder).readString(); + FastStringableTest_javaStringPropertyTest.put(0, charSequence0); + populate_FastStringableTest_javaStringPropertyTest0((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + populate_FastStringableTest_javaStringPropertyTest1((FastStringableTest_javaStringPropertyTest), (customization), (decoder)); + return FastStringableTest_javaStringPropertyTest; + } + + private void populate_FastStringableTest_javaStringPropertyTest0(IndexedRecord FastStringableTest_javaStringPropertyTest, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FastStringableTest_javaStringPropertyTest.put(1, null); + } else { + if (unionIndex0 == 1) { + String charSequence1 = (decoder).readString(); + FastStringableTest_javaStringPropertyTest.put(1, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testUnionString': "+ unionIndex0)); + } + } + List testStringArray1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = FastStringableTest_javaStringPropertyTest.get(2); + if (oldArray0 instanceof List) { + testStringArray1 = ((List) oldArray0); + if (testStringArray1 instanceof GenericArray) { + ((GenericArray) testStringArray1).reset(); + } else { + testStringArray1 .clear(); + } + } else { + testStringArray1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), testStringArray0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testStringMap1 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), ((int) chunkLen1))); + } else { + Map testStringMapReuse0 = null; + Object oldMap0 = FastStringableTest_javaStringPropertyTest.get(3); + if (oldMap0 instanceof Map) { + testStringMapReuse0 = ((Map) oldMap0); + } + if (testStringMapReuse0 != (null)) { + testStringMapReuse0 .clear(); + testStringMap1 = testStringMapReuse0; + } else { + testStringMap1 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + testStringMap1 = ((Map)(customization).getNewMapOverrideFunc().apply(FastStringableTest_javaStringPropertyTest.get(3), 0)); + } else { + testStringMap1 = new HashMap(0); + } + } + FastStringableTest_javaStringPropertyTest.put(3, testStringMap1); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java new file mode 100644 index 000000000..c596fa7bd --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978.java @@ -0,0 +1,1115 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Map_of_TestRecord_SpecificDeserializer_1100791978_1100791978(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex7 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex7)); + } + } + List testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + if (testFixedArray0 instanceof GenericArray) { + ((GenericArray) testFixedArray0).reset(); + } else { + testFixedArray0 .clear(); + } + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + if (testFixedUnionArray0 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray0).reset(); + } else { + testFixedUnionArray0 .clear(); + } + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + if (testEnumArray0 instanceof GenericArray) { + ((GenericArray) testEnumArray0).reset(); + } else { + testEnumArray0 .clear(); + } + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + if (testEnumUnionArray0 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray0).reset(); + } else { + testEnumUnionArray0 .clear(); + } + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + if (recordsArray0 instanceof GenericArray) { + ((GenericArray) recordsArray0).reset(); + } else { + recordsArray0 .clear(); + } + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + if (recordsArrayMap0 instanceof GenericArray) { + ((GenericArray) recordsArrayMap0).reset(); + } else { + recordsArrayMap0 .clear(); + } + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + if (stringArray0 instanceof GenericArray) { + ((GenericArray) stringArray0).reset(); + } else { + stringArray0 .clear(); + } + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema mapMapValueSchema0; + private final Schema mapValueOptionSchema0; + private final Schema field0; + + public Map_of_UNION_GenericDeserializer_2140000109_2140000109(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapValueSchema0 = readerSchema.getValueType(); + this.mapValueOptionSchema0 = mapMapValueSchema0 .getTypes().get(1); + this.field0 = mapValueOptionSchema0 .getField("field").schema(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapValueOptionSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapValueOptionSchema0); + } + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + record.put(0, null); + } else { + if (unionIndex1 == 1) { + Utf8 charSequence0; + Object oldString0 = record.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + record.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex1)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/Map_of_UNION_SpecificDeserializer_971650236_971650236.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/Map_of_UNION_SpecificDeserializer_971650236_971650236.java new file mode 100644 index 000000000..147edaaff --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/Map_of_UNION_SpecificDeserializer_971650236_971650236.java @@ -0,0 +1,1125 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_UNION_SpecificDeserializer_971650236_971650236 + implements FastDeserializer> +{ + + private final Schema readerSchema; + + public Map_of_UNION_SpecificDeserializer_971650236_971650236(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex1)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex2)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex3)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex4)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex5 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex5)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex6 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex6)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex7 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex7)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + List testFixedArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + if (testFixedArray0 instanceof GenericArray) { + ((GenericArray) testFixedArray0).reset(); + } else { + testFixedArray0 .clear(); + } + } else { + testFixedArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testFixedUnionArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + if (testFixedUnionArray0 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray0).reset(); + } else { + testFixedUnionArray0 .clear(); + } + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + if (testEnumArray0 instanceof GenericArray) { + ((GenericArray) testEnumArray0).reset(); + } else { + testEnumArray0 .clear(); + } + } else { + testEnumArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 testEnumUnionArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + if (testEnumUnionArray0 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray0).reset(); + } else { + testEnumUnionArray0 .clear(); + } + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsArray0 = null; + long chunkLen5 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + if (recordsArray0 instanceof GenericArray) { + ((GenericArray) recordsArray0).reset(); + } else { + recordsArray0 .clear(); + } + } else { + recordsArray0 = new ArrayList(((int) chunkLen5)); + } + while (chunkLen5 > 0) { + for (int counter5 = 0; (counter5 recordsMap0 = null; + long chunkLen6 = (decoder.readMapStart()); + if (chunkLen6 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen6))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen6 * 4)+ 2)/ 3))); + } + } + do { + for (int counter6 = 0; (counter6 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex15 = (decoder.readIndex()); + if (unionIndex15 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex15 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen7 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen7)); + } + while (chunkLen7 > 0) { + for (int counter7 = 0; (counter7 recordsMapUnionOption0 = null; + long chunkLen8 = (decoder.readMapStart()); + if (chunkLen8 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen8))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen8 * 4)+ 2)/ 3))); + } + } + do { + for (int counter8 = 0; (counter8 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex17)); + } + } + List> recordsArrayMap0 = null; + long chunkLen9 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + if (recordsArrayMap0 instanceof GenericArray) { + ((GenericArray) recordsArrayMap0).reset(); + } else { + recordsArrayMap0 .clear(); + } + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen9)); + } + while (chunkLen9 > 0) { + for (int counter9 = 0; (counter9 recordsArrayMapElem0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen10))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen9 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen11 = (decoder.readMapStart()); + if (chunkLen11 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen11))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen11 * 4)+ 2)/ 3))); + } + } + do { + for (int counter11 = 0; (counter11 recordsMapArrayValue0 = null; + long chunkLen12 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex21 = (decoder.readIndex()); + if (unionIndex21 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex21 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen13 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen13)); + } + while (chunkLen13 > 0) { + for (int counter13 = 0; (counter13 recordsArrayMapUnionOptionElem0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen14))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen13 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex21)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex23 = (decoder.readIndex()); + if (unionIndex23 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex23 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen15))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen15 * 4)+ 2)/ 3))); + } + } + do { + for (int counter15 = 0; (counter15 recordsMapArrayUnionOptionValue0 = null; + long chunkLen16 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex23)); + } + } + int unionIndex25 = (decoder.readIndex()); + if (unionIndex25 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex25 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex25 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex25 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex25)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen17 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen17)); + } + while (chunkLen17 > 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 0) { + for (int counter20 = 0; (counter20 stringArray0 = null; + long chunkLen21 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + if (stringArray0 instanceof GenericArray) { + ((GenericArray) stringArray0).reset(); + } else { + stringArray0 .clear(); + } + } else { + stringArray0 = new ArrayList(((int) chunkLen21)); + } + while (chunkLen21 > 0) { + for (int counter21 = 0; (counter21 > +{ + + private final Schema readerSchema; + private final Schema unionOptionMapValueSchema0; + + public Map_of_record_GenericDeserializer_1223705675_568621313(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionOptionMapValueSchema0 = readerSchema.getValueType(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":{\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}}"); + } else { + if (unionIndex0 == 1) { + Map unionOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map unionOptionReuse0 = null; + if ((reuse) instanceof Map) { + unionOptionReuse0 = ((Map)(reuse)); + } + if (unionOptionReuse0 != (null)) { + unionOptionReuse0 .clear(); + unionOption0 = unionOptionReuse0; + } else { + unionOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + unionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + unionOption0 = new HashMap(0); + } + } + return unionOption0; + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == unionOptionMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(unionOptionMapValueSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/Map_of_record_GenericDeserializer_1677529043_1677529043.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/Map_of_record_GenericDeserializer_1677529043_1677529043.java new file mode 100644 index 000000000..9b9ea77c6 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/Map_of_record_GenericDeserializer_1677529043_1677529043.java @@ -0,0 +1,95 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class Map_of_record_GenericDeserializer_1677529043_1677529043 + implements FastDeserializer> +{ + + private final Schema readerSchema; + private final Schema mapMapValueSchema0; + private final Schema field0; + + public Map_of_record_GenericDeserializer_1677529043_1677529043(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapValueSchema0 = readerSchema.getValueType(); + this.field0 = mapMapValueSchema0 .getField("field").schema(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapMapValueSchema0); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + record.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = record.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + record.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java new file mode 100644 index 000000000..71c7c7615 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609.java @@ -0,0 +1,61 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RecordWithLargeUnionField_SpecificDeserializer_1132455741_1570175609(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserialize(com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRecordWithLargeUnionField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField deserializeRecordWithLargeUnionField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField RecordWithLargeUnionField; + if ((reuse)!= null) { + RecordWithLargeUnionField = ((com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField)(reuse)); + } else { + RecordWithLargeUnionField = new com.linkedin.avro.fastserde.generated.avro.RecordWithLargeUnionField(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + Utf8 charSequence0; + Object oldString0 = RecordWithLargeUnionField.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RecordWithLargeUnionField.put(0, charSequence0); + } else { + if (unionIndex0 == 1) { + RecordWithLargeUnionField.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 2) { + throw new AvroTypeException(new StringBuilder().append("Found").append(" \"byt").append("es\", ").append("expec").append("ting ").append("[\"str").append("ing\",").append(" \"int").append("\"]").toString()); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + } + return RecordWithLargeUnionField; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java new file mode 100644 index 000000000..0ceb78552 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691.java @@ -0,0 +1,47 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RemovedTypesTestRecord_SpecificDeserializer_1438463600_36310691(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; + if ((reuse)!= null) { + RemovedTypesTestRecord = ((com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord)(reuse)); + } else { + RemovedTypesTestRecord = new com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord(); + } + Utf8 charSequence0; + Object oldString0 = RemovedTypesTestRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RemovedTypesTestRecord.put(0, charSequence0); + return RemovedTypesTestRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java new file mode 100644 index 000000000..eadc0898f --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691.java @@ -0,0 +1,406 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public RemovedTypesTestRecord_SpecificDeserializer_605055252_36310691(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeRemovedTypesTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord deserializeRemovedTypesTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord; + if ((reuse)!= null) { + RemovedTypesTestRecord = ((com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord)(reuse)); + } else { + RemovedTypesTestRecord = new com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord(); + } + Utf8 charSequence0; + Object oldString0 = RemovedTypesTestRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + RemovedTypesTestRecord.put(0, charSequence0); + populate_RemovedTypesTestRecord0((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord1((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord2((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord3((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord4((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord5((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord6((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord7((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord8((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord9((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord10((RemovedTypesTestRecord), (customization), (decoder)); + populate_RemovedTypesTestRecord11((RemovedTypesTestRecord), (customization), (decoder)); + return RemovedTypesTestRecord; + } + + private void populate_RemovedTypesTestRecord0(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.skipBytes(); + long chunkLen0 = (decoder.readArrayStart()); + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 0) { + do { + for (int counter1 = 0; (counter1 0); + } + } + + private void populate_RemovedTypesTestRecord2(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen2 = (decoder.readArrayStart()); + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 0) { + do { + for (int counter3 = 0; (counter3 0); + } + } + + private void populate_RemovedTypesTestRecord3(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.skipFixed(1); + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + } else { + if (unionIndex3 == 1) { + decoder.skipFixed(1); + } else { + throw new RuntimeException(("Illegal union index for 'removedFixedUnion': "+ unionIndex3)); + } + } + } + + private void populate_RemovedTypesTestRecord4(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen4 = (decoder.readArrayStart()); + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 0) { + do { + for (int counter5 = 0; (counter5 0); + } + } + + private void populate_RemovedTypesTestRecord5(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen6 = (decoder.readArrayStart()); + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 0) { + do { + for (int counter7 = 0; (counter7 0); + } + } + + private void populate_RemovedTypesTestRecord6(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + decoder.readEnum(); + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + } else { + if (unionIndex6 == 1) { + decoder.readEnum(); + } else { + throw new RuntimeException(("Illegal union index for 'removedEnumUnion': "+ unionIndex6)); + } + } + } + + private void populate_RemovedTypesTestRecord7(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen8 = (decoder.readArrayStart()); + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 0) { + do { + for (int counter9 = 0; (counter9 0); + } + } + + private void populate_RemovedTypesTestRecord8(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen10 = (decoder.readArrayStart()); + while (chunkLen10 > 0) { + for (int counter10 = 0; (counter10 0) { + do { + for (int counter11 = 0; (counter11 0); + } + } + + private void populate_RemovedTypesTestRecord9(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + deserializeRemovedSubRecord0(null, (decoder), (customization)); + int unionIndex9 = (decoder.readIndex()); + if (unionIndex9 == 0) { + decoder.readNull(); + } else { + if (unionIndex9 == 1) { + deserializeRemovedSubRecord0(null, (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'removedSubRecordUnion': "+ unionIndex9)); + } + } + } + + public void deserializeRemovedSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + decoder.skipString(); + } + + private void populate_RemovedTypesTestRecord10(com.linkedin.avro.fastserde.generated.avro.RemovedTypesTestRecord RemovedTypesTestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + long chunkLen12 = (decoder.readArrayStart()); + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 0) { + for (int counter13 = 0; (counter13 0) { + do { + for (int counter14 = 0; (counter14 0); + } + long chunkLen15 = (decoder.readMapStart()); + if (chunkLen15 > 0) { + do { + for (int counter15 = 0; (counter15 0); + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java new file mode 100644 index 000000000..f7991f039 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/SplitRecordTest1_SpecificDeserializer_1718878379_595582209.java @@ -0,0 +1,176 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class SplitRecordTest1_SpecificDeserializer_1718878379_595582209 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public SplitRecordTest1_SpecificDeserializer_1718878379_595582209(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeSplitRecordTest10((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 deserializeSplitRecordTest10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 SplitRecordTest1; + if ((reuse)!= null) { + SplitRecordTest1 = ((com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1)(reuse)); + } else { + SplitRecordTest1 = new com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1(); + } + SplitRecordTest1 .put(0, deserializeFullRecord0(SplitRecordTest1 .get(0), (decoder), (customization))); + populate_SplitRecordTest10((SplitRecordTest1), (customization), (decoder)); + return SplitRecordTest1; + } + + public com.linkedin.avro.fastserde.generated.avro.FullRecord deserializeFullRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.FullRecord FullRecord; + if ((reuse)!= null) { + FullRecord = ((com.linkedin.avro.fastserde.generated.avro.FullRecord)(reuse)); + } else { + FullRecord = new com.linkedin.avro.fastserde.generated.avro.FullRecord(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + FullRecord.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = FullRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + FullRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex0)); + } + } + FullRecord.put(1, null); + return FullRecord; + } + + private void populate_SplitRecordTest10(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest1 SplitRecordTest1, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + SplitRecordTest1 .put(1, deserializeFullRecord1(SplitRecordTest1 .get(1), (decoder), (customization))); + List record30 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = SplitRecordTest1 .get(2); + if (oldArray0 instanceof List) { + record30 = ((List) oldArray0); + if (record30 instanceof GenericArray) { + ((GenericArray) record30).reset(); + } else { + record30 .clear(); + } + } else { + record30 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public SplitRecordTest2_SpecificDeserializer_595582209_1718878379(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserialize(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeSplitRecordTest20((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 deserializeSplitRecordTest20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 SplitRecordTest2; + if ((reuse)!= null) { + SplitRecordTest2 = ((com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2)(reuse)); + } else { + SplitRecordTest2 = new com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2(); + } + SplitRecordTest2 .put(0, deserializeStringRecord0(SplitRecordTest2 .get(0), (decoder), (customization))); + populate_SplitRecordTest20((SplitRecordTest2), (customization), (decoder)); + return SplitRecordTest2; + } + + public StringRecord deserializeStringRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + StringRecord IntRecord; + if ((reuse)!= null) { + IntRecord = ((StringRecord)(reuse)); + } else { + IntRecord = new StringRecord(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + IntRecord.put(0, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence0; + Object oldString0 = IntRecord.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + IntRecord.put(0, charSequence0); + } else { + throw new RuntimeException(("Illegal union index for 'field1': "+ unionIndex0)); + } + } + populate_IntRecord0((IntRecord), (customization), (decoder)); + return IntRecord; + } + + private void populate_IntRecord0(StringRecord IntRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + } else { + if (unionIndex1 == 1) { + decoder.readInt(); + } else { + throw new RuntimeException(("Illegal union index for 'field2': "+ unionIndex1)); + } + } + } + + private void populate_SplitRecordTest20(com.linkedin.avro.fastserde.generated.avro.SplitRecordTest2 SplitRecordTest2, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + SplitRecordTest2 .put(1, deserializeIntRecord0(SplitRecordTest2 .get(1), (decoder), (customization))); + List record30 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = SplitRecordTest2 .get(2); + if (oldArray0 instanceof List) { + record30 = ((List) oldArray0); + if (record30 instanceof GenericArray) { + ((GenericArray) record30).reset(); + } else { + record30 .clear(); + } + } else { + record30 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public StringableRecord_SpecificDeserializer_842267318_842267318(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserialize(com.linkedin.avro.fastserde.generated.avro.StringableRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + try { + return deserializeStringableRecord0((reuse), (decoder), (customization)); + } catch (NumberFormatException e) { + throw new AvroRuntimeException(e); + } catch (MalformedURLException e) { + throw new AvroRuntimeException(e); + } catch (URISyntaxException e) { + throw new AvroRuntimeException(e); + } + } + + public com.linkedin.avro.fastserde.generated.avro.StringableRecord deserializeStringableRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord; + if ((reuse)!= null) { + StringableRecord = ((com.linkedin.avro.fastserde.generated.avro.StringableRecord)(reuse)); + } else { + StringableRecord = new com.linkedin.avro.fastserde.generated.avro.StringableRecord(); + } + BigInteger charSequence0 = new BigInteger((decoder.readString())); + StringableRecord.put(0, charSequence0); + populate_StringableRecord0((StringableRecord), (customization), (decoder)); + populate_StringableRecord1((StringableRecord), (customization), (decoder)); + populate_StringableRecord2((StringableRecord), (customization), (decoder)); + populate_StringableRecord3((StringableRecord), (customization), (decoder)); + populate_StringableRecord4((StringableRecord), (customization), (decoder)); + return StringableRecord; + } + + private void populate_StringableRecord0(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, URISyntaxException + { + BigDecimal charSequence1 = new BigDecimal((decoder.readString())); + StringableRecord.put(1, charSequence1); + URI charSequence2 = new URI((decoder.readString())); + StringableRecord.put(2, charSequence2); + } + + private void populate_StringableRecord1(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + URL charSequence3 = new URL((decoder.readString())); + StringableRecord.put(3, charSequence3); + File charSequence4 = new File((decoder.readString())); + StringableRecord.put(4, charSequence4); + } + + private void populate_StringableRecord2(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + List urlArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = StringableRecord.get(5); + if (oldArray0 instanceof List) { + urlArray0 = ((List) oldArray0); + if (urlArray0 instanceof GenericArray) { + ((GenericArray) urlArray0).reset(); + } else { + urlArray0 .clear(); + } + } else { + urlArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 urlMap0 = null; + long chunkLen1 = (decoder.readMapStart()); + if (chunkLen1 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), ((int) chunkLen1))); + } else { + Map urlMapReuse0 = null; + Object oldMap0 = StringableRecord.get(6); + if (oldMap0 instanceof Map) { + urlMapReuse0 = ((Map) oldMap0); + } + if (urlMapReuse0 != (null)) { + urlMapReuse0 .clear(); + urlMap0 = urlMapReuse0; + } else { + urlMap0 = new HashMap(((int)(((chunkLen1 * 4)+ 2)/ 3))); + } + } + do { + for (int counter1 = 0; (counter1 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + urlMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(StringableRecord.get(6), 0)); + } else { + urlMap0 = new HashMap(0); + } + } + StringableRecord.put(6, urlMap0); + } + + private void populate_StringableRecord3(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + StringableRecord.put(7, deserializeStringableSubRecord0(StringableRecord.get(7), (decoder), (customization))); + StringableRecord.put(8, deserializeAnotherSubRecord0(StringableRecord.get(8), (decoder), (customization))); + } + + public com.linkedin.avro.fastserde.generated.avro.StringableSubRecord deserializeStringableSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException, URISyntaxException + { + com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord; + if ((reuse)!= null) { + StringableSubRecord = ((com.linkedin.avro.fastserde.generated.avro.StringableSubRecord)(reuse)); + } else { + StringableSubRecord = new com.linkedin.avro.fastserde.generated.avro.StringableSubRecord(); + } + URI charSequence7 = new URI((decoder.readString())); + StringableSubRecord.put(0, charSequence7); + populate_StringableSubRecord0((StringableSubRecord), (customization), (decoder)); + return StringableSubRecord; + } + + private void populate_StringableSubRecord0(com.linkedin.avro.fastserde.generated.avro.StringableSubRecord StringableSubRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, URISyntaxException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + StringableSubRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + Utf8 charSequence8; + Object oldString0 = StringableSubRecord.get(1); + if (oldString0 instanceof Utf8) { + charSequence8 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence8 = (decoder).readString(null); + } + StringableSubRecord.put(1, charSequence8); + } else { + if (unionIndex0 == 2) { + StringableSubRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'nullStringIntUnion': "+ unionIndex0)); + } + } + } + } + + public com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord deserializeAnotherSubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException, URISyntaxException + { + com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord AnotherSubRecord; + if ((reuse)!= null) { + AnotherSubRecord = ((com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord)(reuse)); + } else { + AnotherSubRecord = new com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord(); + } + AnotherSubRecord.put(0, deserializeStringableSubRecord0(AnotherSubRecord.get(0), (decoder), (customization))); + return AnotherSubRecord; + } + + private void populate_StringableRecord4(com.linkedin.avro.fastserde.generated.avro.StringableRecord StringableRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException, NumberFormatException, MalformedURLException, URISyntaxException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + StringableRecord.put(9, null); + } else { + if (unionIndex1 == 1) { + String charSequence9 = (decoder).readString(); + StringableRecord.put(9, charSequence9); + } else { + throw new RuntimeException(("Illegal union index for 'stringUnion': "+ unionIndex1)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java new file mode 100644 index 000000000..f2872d21f --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/TestArrayOfFloats_GenericDeserializer_1408566797_1408566797.java @@ -0,0 +1,46 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class TestArrayOfFloats_GenericDeserializer_1408566797_1408566797 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema array_of_float0; + + public TestArrayOfFloats_GenericDeserializer_1408566797_1408566797(Schema readerSchema) { + this.readerSchema = readerSchema; + this.array_of_float0 = readerSchema.getField("array_of_float").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestArrayOfFloats0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestArrayOfFloats0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord TestArrayOfFloats; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + TestArrayOfFloats = ((IndexedRecord)(reuse)); + } else { + TestArrayOfFloats = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + PrimitiveFloatList array_of_float1 = null; + array_of_float1 = ((PrimitiveFloatList) BufferBackedPrimitiveFloatList.readPrimitiveFloatArray(TestArrayOfFloats.get(0), (decoder))); + TestArrayOfFloats.put(0, array_of_float1); + return TestArrayOfFloats; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/TestRecord_GenericDeserializer_473555078_473555078.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/TestRecord_GenericDeserializer_473555078_473555078.java new file mode 100644 index 000000000..f870432d7 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/TestRecord_GenericDeserializer_473555078_473555078.java @@ -0,0 +1,78 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_GenericDeserializer_473555078_473555078 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema map_field0; + + public TestRecord_GenericDeserializer_473555078_473555078(Schema readerSchema) { + this.readerSchema = readerSchema; + this.map_field0 = readerSchema.getField("map_field").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord TestRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + TestRecord = ((IndexedRecord)(reuse)); + } else { + TestRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map map_field1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), ((int) chunkLen0))); + } else { + Map map_fieldReuse0 = null; + Object oldMap0 = TestRecord.get(0); + if (oldMap0 instanceof Map) { + map_fieldReuse0 = ((Map) oldMap0); + } + if (map_fieldReuse0 != (null)) { + map_fieldReuse0 .clear(); + map_field1 = map_fieldReuse0; + } else { + map_field1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map_field1 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(0), 0)); + } else { + map_field1 = new HashMap(0); + } + } + TestRecord.put(0, map_field1); + return TestRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/TestRecord_SpecificDeserializer_1898726132_553331077.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/TestRecord_SpecificDeserializer_1898726132_553331077.java new file mode 100644 index 000000000..41e944775 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/TestRecord_SpecificDeserializer_1898726132_553331077.java @@ -0,0 +1,1079 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_1898726132_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Map enumMappingTestEnum0; + private final Map enumMappingTestEnum1; + private final Map enumMappingTestEnum2; + private final Map enumMappingTestEnum3; + + public TestRecord_SpecificDeserializer_1898726132_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + HashMap tempEnumMapping0 = new HashMap(5); + tempEnumMapping0 .put(new Integer(0), new Integer(4)); + tempEnumMapping0 .put(new Integer(1), new Integer(3)); + tempEnumMapping0 .put(new Integer(2), new Integer(1)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + HashMap tempEnumMapping1 = new HashMap(5); + tempEnumMapping1 .put(new Integer(0), new Integer(4)); + tempEnumMapping1 .put(new Integer(1), new Integer(3)); + tempEnumMapping1 .put(new Integer(2), new Integer(1)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + HashMap tempEnumMapping2 = new HashMap(5); + tempEnumMapping2 .put(new Integer(0), new Integer(4)); + tempEnumMapping2 .put(new Integer(1), new Integer(3)); + tempEnumMapping2 .put(new Integer(2), new Integer(1)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + HashMap tempEnumMapping3 = new HashMap(5); + tempEnumMapping3 .put(new Integer(0), new Integer(4)); + tempEnumMapping3 .put(new Integer(1), new Integer(3)); + tempEnumMapping3 .put(new Integer(2), new Integer(1)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(0)); + this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + ArrayList defaultArray0 = new ArrayList(); + TestRecord.put(33, defaultArray0); + ArrayList defaultArray1 = new ArrayList(); + TestRecord.put(34, defaultArray1); + ArrayList defaultArray2 = new ArrayList(); + TestRecord.put(35, defaultArray2); + ArrayList defaultArray3 = new ArrayList(); + TestRecord.put(36, defaultArray3); + ArrayList defaultArray4 = new ArrayList(); + TestRecord.put(37, defaultArray4); + ArrayList defaultArray5 = new ArrayList(); + TestRecord.put(38, defaultArray5); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + } else { + if (unionIndex7 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'removedField': "+ unionIndex7)); + } + } + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + } + + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + if (testFixedArray0 instanceof GenericArray) { + ((GenericArray) testFixedArray0).reset(); + } else { + testFixedArray0 .clear(); + } + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + if (testFixedUnionArray0 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray0).reset(); + } else { + testFixedUnionArray0 .clear(); + } + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + if (testEnumArray0 instanceof GenericArray) { + ((GenericArray) testEnumArray0).reset(); + } else { + testEnumArray0 .clear(); + } + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + if (testEnumUnionArray0 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray0).reset(); + } else { + testEnumUnionArray0 .clear(); + } + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + if (recordsArray0 instanceof GenericArray) { + ((GenericArray) recordsArray0).reset(); + } else { + recordsArray0 .clear(); + } + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + } + + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex16 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex18)); + } + } + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + if (recordsArrayMap0 instanceof GenericArray) { + ((GenericArray) recordsArrayMap0).reset(); + } else { + recordsArrayMap0 .clear(); + } + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex22 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex24 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex24)); + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex26 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex26 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex26 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex26)); + } + } + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/TestRecord_SpecificDeserializer_1991094399_553331077.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/TestRecord_SpecificDeserializer_1991094399_553331077.java new file mode 100644 index 000000000..052314790 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/TestRecord_SpecificDeserializer_1991094399_553331077.java @@ -0,0 +1,1083 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_1991094399_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Map enumMappingTestEnum0; + private final Map enumMappingTestEnum1; + private final Map enumMappingTestEnum2; + private final Map enumMappingTestEnum3; + + public TestRecord_SpecificDeserializer_1991094399_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + HashMap tempEnumMapping0 = new HashMap(6); + tempEnumMapping0 .put(new Integer(0), new Integer(4)); + tempEnumMapping0 .put(new Integer(1), new Integer(3)); + tempEnumMapping0 .put(new Integer(2), new Integer(1)); + tempEnumMapping0 .put(new Integer(3), new Integer(2)); + tempEnumMapping0 .put(new Integer(4), new Integer(0)); + tempEnumMapping0 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + HashMap tempEnumMapping1 = new HashMap(6); + tempEnumMapping1 .put(new Integer(0), new Integer(4)); + tempEnumMapping1 .put(new Integer(1), new Integer(3)); + tempEnumMapping1 .put(new Integer(2), new Integer(1)); + tempEnumMapping1 .put(new Integer(3), new Integer(2)); + tempEnumMapping1 .put(new Integer(4), new Integer(0)); + tempEnumMapping1 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum1 = Collections.unmodifiableMap(tempEnumMapping1); + HashMap tempEnumMapping2 = new HashMap(6); + tempEnumMapping2 .put(new Integer(0), new Integer(4)); + tempEnumMapping2 .put(new Integer(1), new Integer(3)); + tempEnumMapping2 .put(new Integer(2), new Integer(1)); + tempEnumMapping2 .put(new Integer(3), new Integer(2)); + tempEnumMapping2 .put(new Integer(4), new Integer(0)); + tempEnumMapping2 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum2 = Collections.unmodifiableMap(tempEnumMapping2); + HashMap tempEnumMapping3 = new HashMap(6); + tempEnumMapping3 .put(new Integer(0), new Integer(4)); + tempEnumMapping3 .put(new Integer(1), new Integer(3)); + tempEnumMapping3 .put(new Integer(2), new Integer(1)); + tempEnumMapping3 .put(new Integer(3), new Integer(2)); + tempEnumMapping3 .put(new Integer(4), new Integer(0)); + tempEnumMapping3 .put(new Integer(5), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.TestEnum: No match for F")); + this.enumMappingTestEnum3 = Collections.unmodifiableMap(tempEnumMapping3); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + ArrayList defaultArray0 = new ArrayList(); + TestRecord.put(33, defaultArray0); + ArrayList defaultArray1 = new ArrayList(); + TestRecord.put(34, defaultArray1); + ArrayList defaultArray2 = new ArrayList(); + TestRecord.put(35, defaultArray2); + ArrayList defaultArray3 = new ArrayList(); + TestRecord.put(36, defaultArray3); + ArrayList defaultArray4 = new ArrayList(); + TestRecord.put(37, defaultArray4); + ArrayList defaultArray5 = new ArrayList(); + TestRecord.put(38, defaultArray5); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + } else { + if (unionIndex7 == 1) { + decoder.skipString(); + } else { + throw new RuntimeException(("Illegal union index for 'removedField': "+ unionIndex7)); + } + } + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + int unionIndex8 = (decoder.readIndex()); + if (unionIndex8 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex8 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex8)); + } + } + } + + private void populate_TestRecord8(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + if (testFixedArray0 instanceof GenericArray) { + ((GenericArray) testFixedArray0).reset(); + } else { + testFixedArray0 .clear(); + } + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + if (testFixedUnionArray0 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray0).reset(); + } else { + testFixedUnionArray0 .clear(); + } + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + if (testEnumArray0 instanceof GenericArray) { + ((GenericArray) testEnumArray0).reset(); + } else { + testEnumArray0 .clear(); + } + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + if (testEnumUnionArray0 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray0).reset(); + } else { + testEnumUnionArray0 .clear(); + } + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + if (recordsArray0 instanceof GenericArray) { + ((GenericArray) recordsArray0).reset(); + } else { + recordsArray0 .clear(); + } + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + } + + private void populate_TestRecord13(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex16 = (decoder.readIndex()); + if (unionIndex16 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex16 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex18)); + } + } + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + if (recordsArrayMap0 instanceof GenericArray) { + ((GenericArray) recordsArrayMap0).reset(); + } else { + recordsArrayMap0 .clear(); + } + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex22 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex24 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex24)); + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex26 = (decoder.readIndex()); + if (unionIndex26 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex26 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex26 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex26 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex26)); + } + } + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/TestRecord_SpecificDeserializer_553331077_553331077.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/TestRecord_SpecificDeserializer_553331077_553331077.java new file mode 100644 index 000000000..ed71b2ac3 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/TestRecord_SpecificDeserializer_553331077_553331077.java @@ -0,0 +1,1084 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.api.PrimitiveDoubleList; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.api.PrimitiveLongList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.TestEnum; +import com.linkedin.avro.fastserde.generated.avro.TestFixed; +import com.linkedin.avro.fastserde.primitive.PrimitiveBooleanArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveDoubleArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import com.linkedin.avro.fastserde.primitive.PrimitiveLongArrayList; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class TestRecord_SpecificDeserializer_553331077_553331077 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public TestRecord_SpecificDeserializer_553331077_553331077(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserialize(com.linkedin.avro.fastserde.generated.avro.TestRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeTestRecord0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.TestRecord deserializeTestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord; + if ((reuse)!= null) { + TestRecord = ((com.linkedin.avro.fastserde.generated.avro.TestRecord)(reuse)); + } else { + TestRecord = new com.linkedin.avro.fastserde.generated.avro.TestRecord(); + } + TestRecord.put(0, (decoder.readInt())); + populate_TestRecord0((TestRecord), (customization), (decoder)); + populate_TestRecord1((TestRecord), (customization), (decoder)); + populate_TestRecord2((TestRecord), (customization), (decoder)); + populate_TestRecord3((TestRecord), (customization), (decoder)); + populate_TestRecord4((TestRecord), (customization), (decoder)); + populate_TestRecord5((TestRecord), (customization), (decoder)); + populate_TestRecord6((TestRecord), (customization), (decoder)); + populate_TestRecord7((TestRecord), (customization), (decoder)); + populate_TestRecord8((TestRecord), (customization), (decoder)); + populate_TestRecord9((TestRecord), (customization), (decoder)); + populate_TestRecord10((TestRecord), (customization), (decoder)); + populate_TestRecord11((TestRecord), (customization), (decoder)); + populate_TestRecord12((TestRecord), (customization), (decoder)); + populate_TestRecord13((TestRecord), (customization), (decoder)); + populate_TestRecord14((TestRecord), (customization), (decoder)); + populate_TestRecord15((TestRecord), (customization), (decoder)); + populate_TestRecord16((TestRecord), (customization), (decoder)); + populate_TestRecord17((TestRecord), (customization), (decoder)); + populate_TestRecord18((TestRecord), (customization), (decoder)); + return TestRecord; + } + + private void populate_TestRecord0(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + TestRecord.put(1, null); + } else { + if (unionIndex0 == 1) { + TestRecord.put(1, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'testIntUnion': "+ unionIndex0)); + } + } + TestRecord.put(2, (decoder.readLong())); + } + + private void populate_TestRecord1(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex1 = (decoder.readIndex()); + if (unionIndex1 == 0) { + decoder.readNull(); + TestRecord.put(3, null); + } else { + if (unionIndex1 == 1) { + TestRecord.put(3, (decoder.readLong())); + } else { + throw new RuntimeException(("Illegal union index for 'testLongUnion': "+ unionIndex1)); + } + } + TestRecord.put(4, (decoder.readDouble())); + } + + private void populate_TestRecord2(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex2 = (decoder.readIndex()); + if (unionIndex2 == 0) { + decoder.readNull(); + TestRecord.put(5, null); + } else { + if (unionIndex2 == 1) { + TestRecord.put(5, (decoder.readDouble())); + } else { + throw new RuntimeException(("Illegal union index for 'testDoubleUnion': "+ unionIndex2)); + } + } + TestRecord.put(6, (decoder.readFloat())); + } + + private void populate_TestRecord3(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex3 = (decoder.readIndex()); + if (unionIndex3 == 0) { + decoder.readNull(); + TestRecord.put(7, null); + } else { + if (unionIndex3 == 1) { + TestRecord.put(7, (decoder.readFloat())); + } else { + throw new RuntimeException(("Illegal union index for 'testFloatUnion': "+ unionIndex3)); + } + } + TestRecord.put(8, (decoder.readBoolean())); + } + + private void populate_TestRecord4(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex4 = (decoder.readIndex()); + if (unionIndex4 == 0) { + decoder.readNull(); + TestRecord.put(9, null); + } else { + if (unionIndex4 == 1) { + TestRecord.put(9, (decoder.readBoolean())); + } else { + throw new RuntimeException(("Illegal union index for 'testBooleanUnion': "+ unionIndex4)); + } + } + ByteBuffer byteBuffer0; + Object oldBytes0 = TestRecord.get(10); + if (oldBytes0 instanceof ByteBuffer) { + byteBuffer0 = (decoder).readBytes(((ByteBuffer) oldBytes0)); + } else { + byteBuffer0 = (decoder).readBytes((null)); + } + TestRecord.put(10, byteBuffer0); + } + + private void populate_TestRecord5(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex5 = (decoder.readIndex()); + if (unionIndex5 == 0) { + decoder.readNull(); + TestRecord.put(11, null); + } else { + if (unionIndex5 == 1) { + ByteBuffer byteBuffer1; + Object oldBytes1 = TestRecord.get(11); + if (oldBytes1 instanceof ByteBuffer) { + byteBuffer1 = (decoder).readBytes(((ByteBuffer) oldBytes1)); + } else { + byteBuffer1 = (decoder).readBytes((null)); + } + TestRecord.put(11, byteBuffer1); + } else { + throw new RuntimeException(("Illegal union index for 'testBytesUnion': "+ unionIndex5)); + } + } + Utf8 charSequence0; + Object oldString0 = TestRecord.get(12); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + TestRecord.put(12, charSequence0); + } + + private void populate_TestRecord6(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex6 = (decoder.readIndex()); + if (unionIndex6 == 0) { + decoder.readNull(); + TestRecord.put(13, null); + } else { + if (unionIndex6 == 1) { + Utf8 charSequence1; + Object oldString1 = TestRecord.get(13); + if (oldString1 instanceof Utf8) { + charSequence1 = (decoder).readString(((Utf8) oldString1)); + } else { + charSequence1 = (decoder).readString(null); + } + TestRecord.put(13, charSequence1); + } else { + throw new RuntimeException(("Illegal union index for 'testStringUnion': "+ unionIndex6)); + } + } + byte[] testFixed0; + Object oldFixed0 = TestRecord.get(14); + if ((oldFixed0 instanceof GenericFixed)&&(((GenericFixed) oldFixed0).bytes().length == (1))) { + testFixed0 = ((GenericFixed) oldFixed0).bytes(); + } else { + testFixed0 = ( new byte[1]); + } + decoder.readFixed(testFixed0); + TestFixed testFixed1 = new TestFixed(); + testFixed1.bytes(testFixed0); + TestRecord.put(14, testFixed1); + } + + private void populate_TestRecord7(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex7 = (decoder.readIndex()); + if (unionIndex7 == 0) { + decoder.readNull(); + TestRecord.put(15, null); + } else { + if (unionIndex7 == 1) { + byte[] testFixed2; + Object oldFixed1 = TestRecord.get(15); + if ((oldFixed1 instanceof GenericFixed)&&(((GenericFixed) oldFixed1).bytes().length == (1))) { + testFixed2 = ((GenericFixed) oldFixed1).bytes(); + } else { + testFixed2 = ( new byte[1]); + } + decoder.readFixed(testFixed2); + TestFixed testFixed3 = new TestFixed(); + testFixed3.bytes(testFixed2); + TestRecord.put(15, testFixed3); + } else { + throw new RuntimeException(("Illegal union index for 'testFixedUnion': "+ unionIndex7)); + } + } + List testFixedArray0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = TestRecord.get(16); + if (oldArray0 instanceof List) { + testFixedArray0 = ((List) oldArray0); + if (testFixedArray0 instanceof GenericArray) { + ((GenericArray) testFixedArray0).reset(); + } else { + testFixedArray0 .clear(); + } + } else { + testFixedArray0 = new ArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 testFixedUnionArray0 = null; + long chunkLen1 = (decoder.readArrayStart()); + Object oldArray1 = TestRecord.get(17); + if (oldArray1 instanceof List) { + testFixedUnionArray0 = ((List) oldArray1); + if (testFixedUnionArray0 instanceof GenericArray) { + ((GenericArray) testFixedUnionArray0).reset(); + } else { + testFixedUnionArray0 .clear(); + } + } else { + testFixedUnionArray0 = new ArrayList(((int) chunkLen1)); + } + while (chunkLen1 > 0) { + for (int counter1 = 0; (counter1 testEnumArray0 = null; + long chunkLen2 = (decoder.readArrayStart()); + Object oldArray2 = TestRecord.get(20); + if (oldArray2 instanceof List) { + testEnumArray0 = ((List) oldArray2); + if (testEnumArray0 instanceof GenericArray) { + ((GenericArray) testEnumArray0).reset(); + } else { + testEnumArray0 .clear(); + } + } else { + testEnumArray0 = new ArrayList(((int) chunkLen2)); + } + while (chunkLen2 > 0) { + for (int counter2 = 0; (counter2 testEnumUnionArray0 = null; + long chunkLen3 = (decoder.readArrayStart()); + Object oldArray3 = TestRecord.get(21); + if (oldArray3 instanceof List) { + testEnumUnionArray0 = ((List) oldArray3); + if (testEnumUnionArray0 instanceof GenericArray) { + ((GenericArray) testEnumUnionArray0).reset(); + } else { + testEnumUnionArray0 .clear(); + } + } else { + testEnumUnionArray0 = new ArrayList(((int) chunkLen3)); + } + while (chunkLen3 > 0) { + for (int counter3 = 0; (counter3 recordsArray0 = null; + long chunkLen4 = (decoder.readArrayStart()); + Object oldArray4 = TestRecord.get(24); + if (oldArray4 instanceof List) { + recordsArray0 = ((List) oldArray4); + if (recordsArray0 instanceof GenericArray) { + ((GenericArray) recordsArray0).reset(); + } else { + recordsArray0 .clear(); + } + } else { + recordsArray0 = new ArrayList(((int) chunkLen4)); + } + while (chunkLen4 > 0) { + for (int counter4 = 0; (counter4 recordsMap0 = null; + long chunkLen5 = (decoder.readMapStart()); + if (chunkLen5 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), ((int) chunkLen5))); + } else { + Map recordsMapReuse0 = null; + Object oldMap0 = TestRecord.get(25); + if (oldMap0 instanceof Map) { + recordsMapReuse0 = ((Map) oldMap0); + } + if (recordsMapReuse0 != (null)) { + recordsMapReuse0 .clear(); + recordsMap0 = recordsMapReuse0; + } else { + recordsMap0 = new HashMap(((int)(((chunkLen5 * 4)+ 2)/ 3))); + } + } + do { + for (int counter5 = 0; (counter5 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMap0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(25), 0)); + } else { + recordsMap0 = new HashMap(0); + } + } + TestRecord.put(25, recordsMap0); + int unionIndex14 = (decoder.readIndex()); + if (unionIndex14 == 0) { + decoder.readNull(); + TestRecord.put(26, null); + } else { + if (unionIndex14 == 1) { + List recordsArrayUnionOption0 = null; + long chunkLen6 = (decoder.readArrayStart()); + Object oldArray5 = TestRecord.get(26); + if (oldArray5 instanceof List) { + recordsArrayUnionOption0 = ((List) oldArray5); + if (recordsArrayUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayUnionOption0).reset(); + } else { + recordsArrayUnionOption0 .clear(); + } + } else { + recordsArrayUnionOption0 = new ArrayList(((int) chunkLen6)); + } + while (chunkLen6 > 0) { + for (int counter6 = 0; (counter6 recordsMapUnionOption0 = null; + long chunkLen7 = (decoder.readMapStart()); + if (chunkLen7 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), ((int) chunkLen7))); + } else { + Map recordsMapUnionOptionReuse0 = null; + Object oldMap1 = TestRecord.get(27); + if (oldMap1 instanceof Map) { + recordsMapUnionOptionReuse0 = ((Map) oldMap1); + } + if (recordsMapUnionOptionReuse0 != (null)) { + recordsMapUnionOptionReuse0 .clear(); + recordsMapUnionOption0 = recordsMapUnionOptionReuse0; + } else { + recordsMapUnionOption0 = new HashMap(((int)(((chunkLen7 * 4)+ 2)/ 3))); + } + } + do { + for (int counter7 = 0; (counter7 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(27), 0)); + } else { + recordsMapUnionOption0 = new HashMap(0); + } + } + TestRecord.put(27, recordsMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapUnion': "+ unionIndex16)); + } + } + List> recordsArrayMap0 = null; + long chunkLen8 = (decoder.readArrayStart()); + Object oldArray6 = TestRecord.get(28); + if (oldArray6 instanceof List) { + recordsArrayMap0 = ((List) oldArray6); + if (recordsArrayMap0 instanceof GenericArray) { + ((GenericArray) recordsArrayMap0).reset(); + } else { + recordsArrayMap0 .clear(); + } + } else { + recordsArrayMap0 = new ArrayList>(((int) chunkLen8)); + } + while (chunkLen8 > 0) { + for (int counter8 = 0; (counter8 recordsArrayMapElem0 = null; + long chunkLen9 = (decoder.readMapStart()); + if (chunkLen9 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, ((int) chunkLen9))); + } else { + Map recordsArrayMapElemReuse0 = null; + if (recordsArrayMapArrayElementReuseVar0 instanceof Map) { + recordsArrayMapElemReuse0 = ((Map) recordsArrayMapArrayElementReuseVar0); + } + if (recordsArrayMapElemReuse0 != (null)) { + recordsArrayMapElemReuse0 .clear(); + recordsArrayMapElem0 = recordsArrayMapElemReuse0; + } else { + recordsArrayMapElem0 = new HashMap(((int)(((chunkLen9 * 4)+ 2)/ 3))); + } + } + do { + for (int counter9 = 0; (counter9 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapArrayElementReuseVar0, 0)); + } else { + recordsArrayMapElem0 = new HashMap(0); + } + } + recordsArrayMap0 .add(recordsArrayMapElem0); + } + chunkLen8 = (decoder.arrayNext()); + } + TestRecord.put(28, recordsArrayMap0); + } + + private void populate_TestRecord14(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + Map> recordsMapArray0 = null; + long chunkLen10 = (decoder.readMapStart()); + if (chunkLen10 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), ((int) chunkLen10))); + } else { + Map> recordsMapArrayReuse0 = null; + Object oldMap2 = TestRecord.get(29); + if (oldMap2 instanceof Map) { + recordsMapArrayReuse0 = ((Map) oldMap2); + } + if (recordsMapArrayReuse0 != (null)) { + recordsMapArrayReuse0 .clear(); + recordsMapArray0 = recordsMapArrayReuse0; + } else { + recordsMapArray0 = new HashMap>(((int)(((chunkLen10 * 4)+ 2)/ 3))); + } + } + do { + for (int counter10 = 0; (counter10 recordsMapArrayValue0 = null; + long chunkLen11 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayValue0 = ((List) null); + if (recordsMapArrayValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayValue0).reset(); + } else { + recordsMapArrayValue0 .clear(); + } + } else { + recordsMapArrayValue0 = new ArrayList(((int) chunkLen11)); + } + while (chunkLen11 > 0) { + for (int counter11 = 0; (counter11 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArray0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(29), 0)); + } else { + recordsMapArray0 = new HashMap>(0); + } + } + TestRecord.put(29, recordsMapArray0); + int unionIndex20 = (decoder.readIndex()); + if (unionIndex20 == 0) { + decoder.readNull(); + TestRecord.put(30, null); + } else { + if (unionIndex20 == 1) { + List> recordsArrayMapUnionOption0 = null; + long chunkLen12 = (decoder.readArrayStart()); + Object oldArray7 = TestRecord.get(30); + if (oldArray7 instanceof List) { + recordsArrayMapUnionOption0 = ((List) oldArray7); + if (recordsArrayMapUnionOption0 instanceof GenericArray) { + ((GenericArray) recordsArrayMapUnionOption0).reset(); + } else { + recordsArrayMapUnionOption0 .clear(); + } + } else { + recordsArrayMapUnionOption0 = new ArrayList>(((int) chunkLen12)); + } + while (chunkLen12 > 0) { + for (int counter12 = 0; (counter12 recordsArrayMapUnionOptionElem0 = null; + long chunkLen13 = (decoder.readMapStart()); + if (chunkLen13 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, ((int) chunkLen13))); + } else { + Map recordsArrayMapUnionOptionElemReuse0 = null; + if (recordsArrayMapUnionOptionArrayElementReuseVar0 instanceof Map) { + recordsArrayMapUnionOptionElemReuse0 = ((Map) recordsArrayMapUnionOptionArrayElementReuseVar0); + } + if (recordsArrayMapUnionOptionElemReuse0 != (null)) { + recordsArrayMapUnionOptionElemReuse0 .clear(); + recordsArrayMapUnionOptionElem0 = recordsArrayMapUnionOptionElemReuse0; + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(((int)(((chunkLen13 * 4)+ 2)/ 3))); + } + } + do { + for (int counter13 = 0; (counter13 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsArrayMapUnionOptionElem0 = ((Map)(customization).getNewMapOverrideFunc().apply(recordsArrayMapUnionOptionArrayElementReuseVar0, 0)); + } else { + recordsArrayMapUnionOptionElem0 = new HashMap(0); + } + } + recordsArrayMapUnionOption0 .add(recordsArrayMapUnionOptionElem0); + } + chunkLen12 = (decoder.arrayNext()); + } + TestRecord.put(30, recordsArrayMapUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsArrayMapUnion': "+ unionIndex20)); + } + } + } + + private void populate_TestRecord15(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex22 = (decoder.readIndex()); + if (unionIndex22 == 0) { + decoder.readNull(); + TestRecord.put(31, null); + } else { + if (unionIndex22 == 1) { + Map> recordsMapArrayUnionOption0 = null; + long chunkLen14 = (decoder.readMapStart()); + if (chunkLen14 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), ((int) chunkLen14))); + } else { + Map> recordsMapArrayUnionOptionReuse0 = null; + Object oldMap3 = TestRecord.get(31); + if (oldMap3 instanceof Map) { + recordsMapArrayUnionOptionReuse0 = ((Map) oldMap3); + } + if (recordsMapArrayUnionOptionReuse0 != (null)) { + recordsMapArrayUnionOptionReuse0 .clear(); + recordsMapArrayUnionOption0 = recordsMapArrayUnionOptionReuse0; + } else { + recordsMapArrayUnionOption0 = new HashMap>(((int)(((chunkLen14 * 4)+ 2)/ 3))); + } + } + do { + for (int counter14 = 0; (counter14 recordsMapArrayUnionOptionValue0 = null; + long chunkLen15 = (decoder.readArrayStart()); + if (null instanceof List) { + recordsMapArrayUnionOptionValue0 = ((List) null); + if (recordsMapArrayUnionOptionValue0 instanceof GenericArray) { + ((GenericArray) recordsMapArrayUnionOptionValue0).reset(); + } else { + recordsMapArrayUnionOptionValue0 .clear(); + } + } else { + recordsMapArrayUnionOptionValue0 = new ArrayList(((int) chunkLen15)); + } + while (chunkLen15 > 0) { + for (int counter15 = 0; (counter15 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + recordsMapArrayUnionOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(TestRecord.get(31), 0)); + } else { + recordsMapArrayUnionOption0 = new HashMap>(0); + } + } + TestRecord.put(31, recordsMapArrayUnionOption0); + } else { + throw new RuntimeException(("Illegal union index for 'recordsMapArrayUnion': "+ unionIndex22)); + } + } + int unionIndex24 = (decoder.readIndex()); + if (unionIndex24 == 0) { + decoder.readNull(); + TestRecord.put(32, null); + } else { + if (unionIndex24 == 1) { + TestRecord.put(32, deserializeSubRecord0(TestRecord.get(32), (decoder), (customization))); + } else { + if (unionIndex24 == 2) { + Utf8 charSequence4; + Object oldString4 = TestRecord.get(32); + if (oldString4 instanceof Utf8) { + charSequence4 = (decoder).readString(((Utf8) oldString4)); + } else { + charSequence4 = (decoder).readString(null); + } + TestRecord.put(32, charSequence4); + } else { + if (unionIndex24 == 3) { + TestRecord.put(32, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex24)); + } + } + } + } + } + + private void populate_TestRecord16(com.linkedin.avro.fastserde.generated.avro.TestRecord TestRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + PrimitiveBooleanList booleanArray0 = null; + long chunkLen16 = (decoder.readArrayStart()); + Object oldArray8 = TestRecord.get(33); + if (oldArray8 instanceof PrimitiveBooleanList) { + booleanArray0 = ((PrimitiveBooleanList) oldArray8); + booleanArray0 .clear(); + } else { + booleanArray0 = new PrimitiveBooleanArrayList(((int) chunkLen16)); + } + while (chunkLen16 > 0) { + for (int counter16 = 0; (counter16 0) { + for (int counter17 = 0; (counter17 0) { + for (int counter18 = 0; (counter18 0) { + for (int counter19 = 0; (counter19 stringArray0 = null; + long chunkLen20 = (decoder.readArrayStart()); + Object oldArray12 = TestRecord.get(38); + if (oldArray12 instanceof List) { + stringArray0 = ((List) oldArray12); + if (stringArray0 instanceof GenericArray) { + ((GenericArray) stringArray0).reset(); + } else { + stringArray0 .clear(); + } + } else { + stringArray0 = new ArrayList(((int) chunkLen20)); + } + while (chunkLen20 > 0) { + for (int counter20 = 0; (counter20 +{ + + private final Schema readerSchema; + private final Schema recordRecordSchema0; + + public UNION_GenericDeserializer_1971822364_1672473580(Schema readerSchema) { + this.readerSchema = readerSchema; + this.recordRecordSchema0 = readerSchema.getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == recordRecordSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(recordRecordSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/UNION_GenericDeserializer_2018567528_1606337179.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/UNION_GenericDeserializer_2018567528_1606337179.java new file mode 100644 index 000000000..98f9a4ecf --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/UNION_GenericDeserializer_2018567528_1606337179.java @@ -0,0 +1,68 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class UNION_GenericDeserializer_2018567528_1606337179 + implements FastDeserializer> +{ + + private final Schema readerSchema; + private final Schema arrayArraySchema0; + private final Schema arrayArrayElemSchema0; + + public UNION_GenericDeserializer_2018567528_1606337179(Schema readerSchema) { + this.readerSchema = readerSchema; + this.arrayArraySchema0 = readerSchema.getTypes().get(1); + this.arrayArrayElemSchema0 = arrayArraySchema0 .getElementType(); + } + + public List deserialize(List reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + List array0 = null; + long chunkLen0 = (decoder.readArrayStart()); + if ((reuse) instanceof List) { + array0 = ((List)(reuse)); + if (array0 instanceof GenericArray) { + ((GenericArray) array0).reset(); + } else { + array0 .clear(); + } + } else { + array0 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), arrayArraySchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 > +{ + + private final Schema readerSchema; + private final Schema mapMapSchema0; + private final Schema mapMapValueSchema0; + + public UNION_GenericDeserializer_568621313_1223705675(Schema readerSchema) { + this.readerSchema = readerSchema; + this.mapMapSchema0 = readerSchema.getTypes().get(1); + this.mapMapValueSchema0 = mapMapSchema0 .getValueType(); + } + + public Map deserialize(Map reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + Map map0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), ((int) chunkLen0))); + } else { + Map mapReuse0 = null; + if ((reuse) instanceof Map) { + mapReuse0 = ((Map)(reuse)); + } + if (mapReuse0 != (null)) { + mapReuse0 .clear(); + map0 = mapReuse0; + } else { + map0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + map0 = ((Map)(customization).getNewMapOverrideFunc().apply((reuse), 0)); + } else { + map0 = new HashMap(0); + } + } + return map0; + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == mapMapValueSchema0)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(mapMapValueSchema0); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java new file mode 100644 index 000000000..2c79fd000 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.generated.avro.MyEnumV1; +import com.linkedin.avro.fastserde.generated.avro.MyEnumV2; +import com.linkedin.avroutil1.Enums; +import org.apache.avro.Schema; +import org.apache.avro.io.Decoder; + +public class UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public UnionOfRecordsWithSameNameEnumField_SpecificDeserializer_1341667615_1341667615(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserialize(com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializeUnionOfRecordsWithSameNameEnumField0((reuse), (decoder), (customization)); + } + + public com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField deserializeUnionOfRecordsWithSameNameEnumField0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField UnionOfRecordsWithSameNameEnumField; + if ((reuse)!= null) { + UnionOfRecordsWithSameNameEnumField = ((com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField)(reuse)); + } else { + UnionOfRecordsWithSameNameEnumField = new com.linkedin.avro.fastserde.generated.avro.UnionOfRecordsWithSameNameEnumField(); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV10(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); + } else { + if (unionIndex0 == 1) { + UnionOfRecordsWithSameNameEnumField.put(0, deserializeMyRecordV20(UnionOfRecordsWithSameNameEnumField.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + return UnionOfRecordsWithSameNameEnumField; + } + + public com.linkedin.avro.fastserde.generated.avro.MyRecordV1 deserializeMyRecordV10(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.MyRecordV1 MyRecordV1; + if ((reuse)!= null) { + MyRecordV1 = ((com.linkedin.avro.fastserde.generated.avro.MyRecordV1)(reuse)); + } else { + MyRecordV1 = new com.linkedin.avro.fastserde.generated.avro.MyRecordV1(); + } + MyRecordV1 .put(0, Enums.getConstant(MyEnumV1 .class, (decoder.readEnum()))); + return MyRecordV1; + } + + public com.linkedin.avro.fastserde.generated.avro.MyRecordV2 deserializeMyRecordV20(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + com.linkedin.avro.fastserde.generated.avro.MyRecordV2 MyRecordV2; + if ((reuse)!= null) { + MyRecordV2 = ((com.linkedin.avro.fastserde.generated.avro.MyRecordV2)(reuse)); + } else { + MyRecordV2 = new com.linkedin.avro.fastserde.generated.avro.MyRecordV2(); + } + MyRecordV2 .put(0, Enums.getConstant(MyEnumV2 .class, (decoder.readEnum()))); + return MyRecordV2; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/recordName_GenericDeserializer_1743054079_1743054079.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/recordName_GenericDeserializer_1743054079_1743054079.java new file mode 100644 index 000000000..5cc3ac6b0 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/recordName_GenericDeserializer_1743054079_1743054079.java @@ -0,0 +1,67 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class recordName_GenericDeserializer_1743054079_1743054079 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema unionField0; + + public recordName_GenericDeserializer_1743054079_1743054079(Schema readerSchema) { + this.readerSchema = readerSchema; + this.unionField0 = readerSchema.getField("unionField").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecordName0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecordName0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord recordName; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + recordName = ((IndexedRecord)(reuse)); + } else { + recordName = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Utf8 charSequence0; + Object oldString0 = recordName.get(0); + if (oldString0 instanceof Utf8) { + charSequence0 = (decoder).readString(((Utf8) oldString0)); + } else { + charSequence0 = (decoder).readString(null); + } + recordName.put(0, charSequence0); + populate_recordName0((recordName), (customization), (decoder)); + return recordName; + } + + private void populate_recordName0(IndexedRecord recordName, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + decoder.readNull(); + recordName.put(1, null); + } else { + if (unionIndex0 == 1) { + recordName.put(1, deserializerecordName0(recordName.get(1), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'unionField': "+ unionIndex0)); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1025741720_1557256887.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1025741720_1557256887.java new file mode 100644 index 000000000..97a7aa130 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1025741720_1557256887.java @@ -0,0 +1,96 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1025741720_1557256887 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_1025741720_1557256887(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + Map someIntsOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } + } + record.put(0, someIntsOption0); + } else { + throw new RuntimeException(("Illegal union index for 'someInts': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1126840752_2099305627.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1126840752_2099305627.java new file mode 100644 index 000000000..6e431eeba --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1126840752_2099305627.java @@ -0,0 +1,50 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1126840752_2099305627 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1126840752_2099305627(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + record.put(0, (decoder.readInt())); + } else { + if (unionIndex0 == 1) { + throw new AvroTypeException("Found \"string\", expecting \"int\""); + } else { + throw new RuntimeException(("Illegal union index for 'someField': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1191367445_653449771.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1191367445_653449771.java new file mode 100644 index 000000000..c4f0b419d --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1191367445_653449771.java @@ -0,0 +1,69 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1191367445_653449771 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_1191367445_653449771(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList someIntsOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someIntsOption0 = ((PrimitiveIntList) oldArray0); + someIntsOption0 .clear(); + } else { + someIntsOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1373882843_1971822364(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + record.put(0, (decoder.readInt())); + } else { + throw new RuntimeException(("Illegal union index for 'someInt': "+ unionIndex0)); + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1556659421_711533897.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1556659421_711533897.java new file mode 100644 index 000000000..58e33760a --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1556659421_711533897.java @@ -0,0 +1,72 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1556659421_711533897 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema subRecord0; + + public record_GenericDeserializer_1556659421_711533897(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"subRecord\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"subRecord\",\"fields\":[{\"name\":\"someInt1\",\"type\":\"int\",\"doc\":\"\"},{\"name\":\"someInt2\",\"type\":\"int\",\"doc\":\"\"}]}"); + } else { + if (unionIndex0 == 1) { + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); + } else { + throw new RuntimeException(("Illegal union index for 'subRecord': "+ unionIndex0)); + } + } + return record; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecord0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecord0); + } + subRecord.put(0, (decoder.readInt())); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + subRecord.put(1, (decoder.readInt())); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1557256887_1025741720.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1557256887_1025741720.java new file mode 100644 index 000000000..483d419a6 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1557256887_1025741720.java @@ -0,0 +1,81 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1557256887_1025741720 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsMapSchema0; + private final Schema someIntsMapValueSchema0; + + public record_GenericDeserializer_1557256887_1025741720(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsMapSchema0 = someInts0 .getTypes().get(1); + this.someIntsMapValueSchema0 = someIntsMapSchema0 .getValueType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map someInts1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } + } + record.put(0, someInts1); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1557256887_753570467.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1557256887_753570467.java new file mode 100644 index 000000000..758fe3c95 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1557256887_753570467.java @@ -0,0 +1,79 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_1557256887_753570467 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsMapSchema0; + + public record_GenericDeserializer_1557256887_753570467(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsMapSchema0 = someInts0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + Map someInts1 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsReuse0 = ((Map) oldMap0); + } + if (someIntsReuse0 != (null)) { + someIntsReuse0 .clear(); + someInts1 = someIntsReuse0; + } else { + someInts1 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someInts1 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someInts1 = new HashMap(0); + } + } + record.put(0, someInts1); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1672473580_1971822364.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1672473580_1971822364.java new file mode 100644 index 000000000..d42ab1aa9 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1672473580_1971822364.java @@ -0,0 +1,50 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1672473580_1971822364 + implements FastDeserializer +{ + + private final Schema readerSchema; + + public record_GenericDeserializer_1672473580_1971822364(Schema readerSchema) { + this.readerSchema = readerSchema; + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"record\",\"name\":\"record\",\"namespace\":\"com.linkedin.avro.fastserde.generated.avro\",\"doc\":\"record\",\"fields\":[{\"name\":\"someInt\",\"type\":\"int\",\"doc\":\"\"}]}"); + } else { + if (unionIndex0 == 1) { + return deserializerecord0((reuse), (decoder), (customization)); + } else { + throw new RuntimeException(("Illegal union index for 'union': "+ unionIndex0)); + } + } + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1971822364_1373882843.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1971822364_1373882843.java new file mode 100644 index 000000000..e125016b0 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_1971822364_1373882843.java @@ -0,0 +1,42 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_1971822364_1373882843 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInt0; + + public record_GenericDeserializer_1971822364_1373882843(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInt0 = readerSchema.getField("someInt").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, (decoder.readInt())); + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_653449771_1191367445.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_653449771_1191367445.java new file mode 100644 index 000000000..ce16ee2b7 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_653449771_1191367445.java @@ -0,0 +1,61 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_653449771_1191367445 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsArraySchema0; + + public record_GenericDeserializer_653449771_1191367445(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsArraySchema0 = someInts0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + PrimitiveIntList someInts1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someInts1 = ((PrimitiveIntList) oldArray0); + someInts1 .clear(); + } else { + someInts1 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema someInts0; + private final Schema someIntsArraySchema0; + private final Schema someIntsArrayElemSchema0; + + public record_GenericDeserializer_653449771_813379571(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + this.someIntsArraySchema0 = someInts0 .getTypes().get(1); + this.someIntsArrayElemSchema0 = someIntsArraySchema0 .getElementType(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + List someInts1 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof List) { + someInts1 = ((List) oldArray0); + someInts1 .clear(); + } else { + someInts1 = new org.apache.avro.generic.GenericData.Array(((int) chunkLen0), someIntsArraySchema0); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema subRecord0; + private final Schema subRecordRecordSchema0; + + public record_GenericDeserializer_711533897_1556659421(Schema readerSchema) { + this.readerSchema = readerSchema; + this.subRecord0 = readerSchema.getField("subRecord").schema(); + this.subRecordRecordSchema0 = subRecord0 .getTypes().get(1); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + record.put(0, deserializesubRecord0(record.get(0), (decoder), (customization))); + return record; + } + + public IndexedRecord deserializesubRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord subRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == subRecordRecordSchema0)) { + subRecord = ((IndexedRecord)(reuse)); + } else { + subRecord = new org.apache.avro.generic.GenericData.Record(subRecordRecordSchema0); + } + subRecord.put(0, (decoder.readInt())); + populate_subRecord0((subRecord), (customization), (decoder)); + return subRecord; + } + + private void populate_subRecord0(IndexedRecord subRecord, DatumReaderCustomization customization, Decoder decoder) + throws IOException + { + subRecord.put(1, (decoder.readInt())); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_753570467_1557256887.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_753570467_1557256887.java new file mode 100644 index 000000000..e46465890 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_753570467_1557256887.java @@ -0,0 +1,87 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; +import org.apache.avro.util.Utf8; + +public class record_GenericDeserializer_753570467_1557256887 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_753570467_1557256887(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"map\",\"values\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + Map someIntsOption0 = null; + long chunkLen0 = (decoder.readMapStart()); + if (chunkLen0 > 0) { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), ((int) chunkLen0))); + } else { + Map someIntsOptionReuse0 = null; + Object oldMap0 = record.get(0); + if (oldMap0 instanceof Map) { + someIntsOptionReuse0 = ((Map) oldMap0); + } + if (someIntsOptionReuse0 != (null)) { + someIntsOptionReuse0 .clear(); + someIntsOption0 = someIntsOptionReuse0; + } else { + someIntsOption0 = new HashMap(((int)(((chunkLen0 * 4)+ 2)/ 3))); + } + } + do { + for (int counter0 = 0; (counter0 0); + } else { + if (((customization)!= null)&&((customization).getNewMapOverrideFunc()!= null)) { + someIntsOption0 = ((Map)(customization).getNewMapOverrideFunc().apply(record.get(0), 0)); + } else { + someIntsOption0 = new HashMap(0); + } + } + record.put(0, someIntsOption0); + } else { + throw new RuntimeException(("Illegal union index for 'someInts': "+ unionIndex0)); + } + } + return record; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_813379571_653449771.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_813379571_653449771.java new file mode 100644 index 000000000..ef8ddfa88 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/deserialization/AVRO_1_9/record_GenericDeserializer_813379571_653449771.java @@ -0,0 +1,87 @@ + +package com.linkedin.avro.fastserde.generated.deserialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastDeserializer; +import com.linkedin.avro.fastserde.customized.DatumReaderCustomization; +import com.linkedin.avro.fastserde.primitive.PrimitiveIntArrayList; +import org.apache.avro.AvroTypeException; +import org.apache.avro.Schema; +import org.apache.avro.generic.GenericArray; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Decoder; + +public class record_GenericDeserializer_813379571_653449771 + implements FastDeserializer +{ + + private final Schema readerSchema; + private final Schema someInts0; + + public record_GenericDeserializer_813379571_653449771(Schema readerSchema) { + this.readerSchema = readerSchema; + this.someInts0 = readerSchema.getField("someInts").schema(); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializerecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializerecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord record; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + record = ((IndexedRecord)(reuse)); + } else { + record = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int unionIndex0 = (decoder.readIndex()); + if (unionIndex0 == 0) { + throw new AvroTypeException("Found \"null\", expecting {\"type\":\"array\",\"items\":\"int\"}"); + } else { + if (unionIndex0 == 1) { + PrimitiveIntList someIntsOption0 = null; + long chunkLen0 = (decoder.readArrayStart()); + Object oldArray0 = record.get(0); + if (oldArray0 instanceof PrimitiveIntList) { + someIntsOption0 = ((PrimitiveIntList) oldArray0); + if (someIntsOption0 instanceof GenericArray) { + ((GenericArray) someIntsOption0).reset(); + } else { + someIntsOption0 .clear(); + } + } else { + someIntsOption0 = new PrimitiveIntArrayList(((int) chunkLen0)); + } + while (chunkLen0 > 0) { + for (int counter0 = 0; (counter0 +{ + + private final Schema readerSchema; + private final Schema testEnum0; + private final Map enumMappingtestEnum0; + + public testRecord_GenericDeserializer_1146484089_1256982207(Schema readerSchema) { + this.readerSchema = readerSchema; + this.testEnum0 = readerSchema.getField("testEnum").schema(); + HashMap tempEnumMapping0 = new HashMap(3); + tempEnumMapping0 .put(new Integer(0), new Integer(0)); + tempEnumMapping0 .put(new Integer(1), new Integer(1)); + tempEnumMapping0 .put(new Integer(2), new AvroTypeException("com.linkedin.avro.fastserde.generated.avro.testEnum: No match for C")); + this.enumMappingtestEnum0 = Collections.unmodifiableMap(tempEnumMapping0); + } + + public IndexedRecord deserialize(IndexedRecord reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + return deserializetestRecord0((reuse), (decoder), (customization)); + } + + public IndexedRecord deserializetestRecord0(Object reuse, Decoder decoder, DatumReaderCustomization customization) + throws IOException + { + IndexedRecord testRecord; + if ((((reuse)!= null)&&((reuse) instanceof IndexedRecord))&&(((IndexedRecord)(reuse)).getSchema() == readerSchema)) { + testRecord = ((IndexedRecord)(reuse)); + } else { + testRecord = new org.apache.avro.generic.GenericData.Record(readerSchema); + } + int enumIndex0 = (decoder.readEnum()); + GenericEnumSymbol enumValue0 = null; + Object enumIndexLookupResult0 = enumMappingtestEnum0 .get(enumIndex0); + if (enumIndexLookupResult0 instanceof Integer) { + enumValue0 = new org.apache.avro.generic.GenericData.EnumSymbol(testEnum0, testEnum0 .getEnumSymbols().get(((Integer) enumIndexLookupResult0))); + } else { + if (enumIndexLookupResult0 instanceof AvroTypeException) { + throw((AvroTypeException) enumIndexLookupResult0); + } else { + throw new RuntimeException(("Illegal enum index for 'com.linkedin.avro.fastserde.generated.avro.testEnum': "+ enumIndex0)); + } + } + testRecord.put(0, enumValue0); + return testRecord; + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/Array_of_BOOLEAN_GenericSerializer_869749973.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/Array_of_BOOLEAN_GenericSerializer_869749973.java new file mode 100644 index 000000000..fc832b116 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/Array_of_BOOLEAN_GenericSerializer_869749973.java @@ -0,0 +1,41 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveBooleanList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.io.Encoder; + +public class Array_of_BOOLEAN_GenericSerializer_869749973 + implements FastSerializer> +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveBooleanList) { + PrimitiveBooleanList primitiveList0 = ((PrimitiveBooleanList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveDoubleList) { + PrimitiveDoubleList primitiveList0 = ((PrimitiveDoubleList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveFloatList) { + PrimitiveFloatList primitiveList0 = ((PrimitiveFloatList) array0); + if (primitiveList0 instanceof BufferBackedPrimitiveFloatList) { + BufferBackedPrimitiveFloatList bufferBackedPrimitiveFloatList = ((BufferBackedPrimitiveFloatList) primitiveList0); + bufferBackedPrimitiveFloatList.writeFloats((encoder)); + } else { + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList0 = ((PrimitiveIntList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + Object array0 = data; + if (array0 instanceof PrimitiveLongList) { + PrimitiveLongList primitiveList0 = ((PrimitiveLongList) array0); + for (int counter0 = 0; (counter0 > +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (int counter0 = 0; (counter0 ) data).get(counter0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/Array_of_record_GenericSerializer_477614132.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/Array_of_record_GenericSerializer_477614132.java new file mode 100644 index 000000000..af72a78a5 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/Array_of_record_GenericSerializer_477614132.java @@ -0,0 +1,53 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Array_of_record_GenericSerializer_477614132 + implements FastSerializer> +{ + + + public void serialize(List data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeArrayStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (int counter0 = 0; (counter0 ) data).get(counter0); + serializeRecord0(record0, (encoder), (customization)); + } + } + (encoder).writeArrayEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java new file mode 100644 index 000000000..d992477b7 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713.java @@ -0,0 +1,4527 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord_GenericSerializer_312360713 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(1))); + (encoder).writeInt(((Integer) data.get(2))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(3))); + (encoder).writeInt(((Integer) data.get(4))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(5))); + (encoder).writeInt(((Integer) data.get(6))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(7))); + (encoder).writeInt(((Integer) data.get(8))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(9))); + (encoder).writeInt(((Integer) data.get(10))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(11))); + (encoder).writeInt(((Integer) data.get(12))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(13))); + (encoder).writeInt(((Integer) data.get(14))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord7(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(15))); + (encoder).writeInt(((Integer) data.get(16))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord8(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(17))); + (encoder).writeInt(((Integer) data.get(18))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord9(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(19))); + (encoder).writeInt(((Integer) data.get(20))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(21))); + (encoder).writeInt(((Integer) data.get(22))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord11(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(23))); + (encoder).writeInt(((Integer) data.get(24))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord12(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(25))); + (encoder).writeInt(((Integer) data.get(26))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord13(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(27))); + (encoder).writeInt(((Integer) data.get(28))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord14(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(29))); + (encoder).writeInt(((Integer) data.get(30))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord15(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(31))); + (encoder).writeInt(((Integer) data.get(32))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord16(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(33))); + (encoder).writeInt(((Integer) data.get(34))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord17(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(35))); + (encoder).writeInt(((Integer) data.get(36))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord18(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(37))); + (encoder).writeInt(((Integer) data.get(38))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord19(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(39))); + (encoder).writeInt(((Integer) data.get(40))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(41))); + (encoder).writeInt(((Integer) data.get(42))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord21(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(43))); + (encoder).writeInt(((Integer) data.get(44))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord22(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(45))); + (encoder).writeInt(((Integer) data.get(46))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord23(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(47))); + (encoder).writeInt(((Integer) data.get(48))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord24(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(49))); + (encoder).writeInt(((Integer) data.get(50))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord25(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(51))); + (encoder).writeInt(((Integer) data.get(52))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord26(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(53))); + (encoder).writeInt(((Integer) data.get(54))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord27(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(55))); + (encoder).writeInt(((Integer) data.get(56))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord28(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(57))); + (encoder).writeInt(((Integer) data.get(58))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord29(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(59))); + (encoder).writeInt(((Integer) data.get(60))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord30(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(61))); + (encoder).writeInt(((Integer) data.get(62))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord31(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(63))); + (encoder).writeInt(((Integer) data.get(64))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord32(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(65))); + (encoder).writeInt(((Integer) data.get(66))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord33(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(67))); + (encoder).writeInt(((Integer) data.get(68))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord34(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(69))); + (encoder).writeInt(((Integer) data.get(70))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord35(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(71))); + (encoder).writeInt(((Integer) data.get(72))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord36(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(73))); + (encoder).writeInt(((Integer) data.get(74))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord37(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(75))); + (encoder).writeInt(((Integer) data.get(76))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord38(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(77))); + (encoder).writeInt(((Integer) data.get(78))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord39(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(79))); + (encoder).writeInt(((Integer) data.get(80))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord40(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(81))); + (encoder).writeInt(((Integer) data.get(82))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord41(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(83))); + (encoder).writeInt(((Integer) data.get(84))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord42(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(85))); + (encoder).writeInt(((Integer) data.get(86))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord43(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(87))); + (encoder).writeInt(((Integer) data.get(88))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord44(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(89))); + (encoder).writeInt(((Integer) data.get(90))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord45(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(91))); + (encoder).writeInt(((Integer) data.get(92))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord46(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(93))); + (encoder).writeInt(((Integer) data.get(94))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord47(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(95))); + (encoder).writeInt(((Integer) data.get(96))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord48(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(97))); + (encoder).writeInt(((Integer) data.get(98))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord49(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(99))); + (encoder).writeInt(((Integer) data.get(100))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord50(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(101))); + (encoder).writeInt(((Integer) data.get(102))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord51(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(103))); + (encoder).writeInt(((Integer) data.get(104))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord52(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(105))); + (encoder).writeInt(((Integer) data.get(106))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord53(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(107))); + (encoder).writeInt(((Integer) data.get(108))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord54(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(109))); + (encoder).writeInt(((Integer) data.get(110))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord55(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(111))); + (encoder).writeInt(((Integer) data.get(112))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord56(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(113))); + (encoder).writeInt(((Integer) data.get(114))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord57(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(115))); + (encoder).writeInt(((Integer) data.get(116))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord58(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(117))); + (encoder).writeInt(((Integer) data.get(118))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord59(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(119))); + (encoder).writeInt(((Integer) data.get(120))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord60(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(121))); + (encoder).writeInt(((Integer) data.get(122))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord61(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(123))); + (encoder).writeInt(((Integer) data.get(124))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord62(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(125))); + (encoder).writeInt(((Integer) data.get(126))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord63(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(127))); + (encoder).writeInt(((Integer) data.get(128))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord64(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(129))); + (encoder).writeInt(((Integer) data.get(130))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord65(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(131))); + (encoder).writeInt(((Integer) data.get(132))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord66(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(133))); + (encoder).writeInt(((Integer) data.get(134))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord67(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(135))); + (encoder).writeInt(((Integer) data.get(136))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord68(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(137))); + (encoder).writeInt(((Integer) data.get(138))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord69(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(139))); + (encoder).writeInt(((Integer) data.get(140))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord70(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(141))); + (encoder).writeInt(((Integer) data.get(142))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord71(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(143))); + (encoder).writeInt(((Integer) data.get(144))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord72(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(145))); + (encoder).writeInt(((Integer) data.get(146))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord73(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(147))); + (encoder).writeInt(((Integer) data.get(148))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord74(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(149))); + (encoder).writeInt(((Integer) data.get(150))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord75(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(151))); + (encoder).writeInt(((Integer) data.get(152))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord76(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(153))); + (encoder).writeInt(((Integer) data.get(154))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord77(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(155))); + (encoder).writeInt(((Integer) data.get(156))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord78(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(157))); + (encoder).writeInt(((Integer) data.get(158))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord79(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(159))); + (encoder).writeInt(((Integer) data.get(160))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord80(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(161))); + (encoder).writeInt(((Integer) data.get(162))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord81(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(163))); + (encoder).writeInt(((Integer) data.get(164))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord82(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(165))); + (encoder).writeInt(((Integer) data.get(166))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord83(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(167))); + (encoder).writeInt(((Integer) data.get(168))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord84(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(169))); + (encoder).writeInt(((Integer) data.get(170))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord85(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(171))); + (encoder).writeInt(((Integer) data.get(172))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord86(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(173))); + (encoder).writeInt(((Integer) data.get(174))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord87(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(175))); + (encoder).writeInt(((Integer) data.get(176))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord88(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(177))); + (encoder).writeInt(((Integer) data.get(178))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord89(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(179))); + (encoder).writeInt(((Integer) data.get(180))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord90(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(181))); + (encoder).writeInt(((Integer) data.get(182))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord91(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(183))); + (encoder).writeInt(((Integer) data.get(184))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord92(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(185))); + (encoder).writeInt(((Integer) data.get(186))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord93(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(187))); + (encoder).writeInt(((Integer) data.get(188))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord94(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(189))); + (encoder).writeInt(((Integer) data.get(190))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord95(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(191))); + (encoder).writeInt(((Integer) data.get(192))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord96(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(193))); + (encoder).writeInt(((Integer) data.get(194))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord97(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(195))); + (encoder).writeInt(((Integer) data.get(196))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord98(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(197))); + (encoder).writeInt(((Integer) data.get(198))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord99(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(199))); + (encoder).writeInt(((Integer) data.get(200))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord100(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(201))); + (encoder).writeInt(((Integer) data.get(202))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord101(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(203))); + (encoder).writeInt(((Integer) data.get(204))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord102(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(205))); + (encoder).writeInt(((Integer) data.get(206))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord103(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(207))); + (encoder).writeInt(((Integer) data.get(208))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord104(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(209))); + (encoder).writeInt(((Integer) data.get(210))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord105(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(211))); + (encoder).writeInt(((Integer) data.get(212))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord106(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(213))); + (encoder).writeInt(((Integer) data.get(214))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord107(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(215))); + (encoder).writeInt(((Integer) data.get(216))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord108(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(217))); + (encoder).writeInt(((Integer) data.get(218))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord109(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(219))); + (encoder).writeInt(((Integer) data.get(220))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord110(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(221))); + (encoder).writeInt(((Integer) data.get(222))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord111(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(223))); + (encoder).writeInt(((Integer) data.get(224))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord112(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(225))); + (encoder).writeInt(((Integer) data.get(226))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord113(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(227))); + (encoder).writeInt(((Integer) data.get(228))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord114(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(229))); + (encoder).writeInt(((Integer) data.get(230))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord115(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(231))); + (encoder).writeInt(((Integer) data.get(232))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord116(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(233))); + (encoder).writeInt(((Integer) data.get(234))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord117(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(235))); + (encoder).writeInt(((Integer) data.get(236))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord118(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(237))); + (encoder).writeInt(((Integer) data.get(238))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord119(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(239))); + (encoder).writeInt(((Integer) data.get(240))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord120(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(241))); + (encoder).writeInt(((Integer) data.get(242))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord121(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(243))); + (encoder).writeInt(((Integer) data.get(244))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord122(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(245))); + (encoder).writeInt(((Integer) data.get(246))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord123(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(247))); + (encoder).writeInt(((Integer) data.get(248))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord124(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(249))); + (encoder).writeInt(((Integer) data.get(250))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord125(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(251))); + (encoder).writeInt(((Integer) data.get(252))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord126(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(253))); + (encoder).writeInt(((Integer) data.get(254))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord127(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(255))); + (encoder).writeInt(((Integer) data.get(256))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord128(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(257))); + (encoder).writeInt(((Integer) data.get(258))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord129(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(259))); + (encoder).writeInt(((Integer) data.get(260))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord130(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(261))); + (encoder).writeInt(((Integer) data.get(262))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord131(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(263))); + (encoder).writeInt(((Integer) data.get(264))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord132(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(265))); + (encoder).writeInt(((Integer) data.get(266))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord133(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(267))); + (encoder).writeInt(((Integer) data.get(268))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord134(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(269))); + (encoder).writeInt(((Integer) data.get(270))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord135(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(271))); + (encoder).writeInt(((Integer) data.get(272))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord136(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(273))); + (encoder).writeInt(((Integer) data.get(274))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord137(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(275))); + (encoder).writeInt(((Integer) data.get(276))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord138(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(277))); + (encoder).writeInt(((Integer) data.get(278))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord139(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(279))); + (encoder).writeInt(((Integer) data.get(280))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord140(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(281))); + (encoder).writeInt(((Integer) data.get(282))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord141(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(283))); + (encoder).writeInt(((Integer) data.get(284))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord142(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(285))); + (encoder).writeInt(((Integer) data.get(286))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord143(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(287))); + (encoder).writeInt(((Integer) data.get(288))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord144(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(289))); + (encoder).writeInt(((Integer) data.get(290))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord145(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(291))); + (encoder).writeInt(((Integer) data.get(292))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord146(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(293))); + (encoder).writeInt(((Integer) data.get(294))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord147(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(295))); + (encoder).writeInt(((Integer) data.get(296))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord148(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(297))); + (encoder).writeInt(((Integer) data.get(298))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord149(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(299))); + (encoder).writeInt(((Integer) data.get(300))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord150(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(301))); + (encoder).writeInt(((Integer) data.get(302))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord151(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(303))); + (encoder).writeInt(((Integer) data.get(304))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord152(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(305))); + (encoder).writeInt(((Integer) data.get(306))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord153(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(307))); + (encoder).writeInt(((Integer) data.get(308))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord154(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(309))); + (encoder).writeInt(((Integer) data.get(310))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord155(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(311))); + (encoder).writeInt(((Integer) data.get(312))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord156(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(313))); + (encoder).writeInt(((Integer) data.get(314))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord157(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(315))); + (encoder).writeInt(((Integer) data.get(316))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord158(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(317))); + (encoder).writeInt(((Integer) data.get(318))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord159(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(319))); + (encoder).writeInt(((Integer) data.get(320))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord160(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(321))); + (encoder).writeInt(((Integer) data.get(322))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord161(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(323))); + (encoder).writeInt(((Integer) data.get(324))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord162(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(325))); + (encoder).writeInt(((Integer) data.get(326))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord163(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(327))); + (encoder).writeInt(((Integer) data.get(328))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord164(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(329))); + (encoder).writeInt(((Integer) data.get(330))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord165(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(331))); + (encoder).writeInt(((Integer) data.get(332))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord166(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(333))); + (encoder).writeInt(((Integer) data.get(334))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord167(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(335))); + (encoder).writeInt(((Integer) data.get(336))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord168(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(337))); + (encoder).writeInt(((Integer) data.get(338))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord169(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(339))); + (encoder).writeInt(((Integer) data.get(340))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord170(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(341))); + (encoder).writeInt(((Integer) data.get(342))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord171(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(343))); + (encoder).writeInt(((Integer) data.get(344))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord172(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(345))); + (encoder).writeInt(((Integer) data.get(346))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord173(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(347))); + (encoder).writeInt(((Integer) data.get(348))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord174(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(349))); + (encoder).writeInt(((Integer) data.get(350))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord175(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(351))); + (encoder).writeInt(((Integer) data.get(352))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord176(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(353))); + (encoder).writeInt(((Integer) data.get(354))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord177(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(355))); + (encoder).writeInt(((Integer) data.get(356))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord178(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(357))); + (encoder).writeInt(((Integer) data.get(358))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord179(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(359))); + (encoder).writeInt(((Integer) data.get(360))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord180(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(361))); + (encoder).writeInt(((Integer) data.get(362))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord181(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(363))); + (encoder).writeInt(((Integer) data.get(364))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord182(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(365))); + (encoder).writeInt(((Integer) data.get(366))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord183(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(367))); + (encoder).writeInt(((Integer) data.get(368))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord184(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(369))); + (encoder).writeInt(((Integer) data.get(370))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord185(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(371))); + (encoder).writeInt(((Integer) data.get(372))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord186(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(373))); + (encoder).writeInt(((Integer) data.get(374))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord187(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(375))); + (encoder).writeInt(((Integer) data.get(376))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord188(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(377))); + (encoder).writeInt(((Integer) data.get(378))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord189(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(379))); + (encoder).writeInt(((Integer) data.get(380))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord190(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(381))); + (encoder).writeInt(((Integer) data.get(382))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord191(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(383))); + (encoder).writeInt(((Integer) data.get(384))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord192(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(385))); + (encoder).writeInt(((Integer) data.get(386))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord193(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(387))); + (encoder).writeInt(((Integer) data.get(388))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord194(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(389))); + (encoder).writeInt(((Integer) data.get(390))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord195(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(391))); + (encoder).writeInt(((Integer) data.get(392))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord196(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(393))); + (encoder).writeInt(((Integer) data.get(394))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord197(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(395))); + (encoder).writeInt(((Integer) data.get(396))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord198(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(397))); + (encoder).writeInt(((Integer) data.get(398))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord199(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(399))); + (encoder).writeInt(((Integer) data.get(400))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord200(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(401))); + (encoder).writeInt(((Integer) data.get(402))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord201(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(403))); + (encoder).writeInt(((Integer) data.get(404))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord202(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(405))); + (encoder).writeInt(((Integer) data.get(406))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord203(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(407))); + (encoder).writeInt(((Integer) data.get(408))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord204(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(409))); + (encoder).writeInt(((Integer) data.get(410))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord205(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(411))); + (encoder).writeInt(((Integer) data.get(412))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord206(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(413))); + (encoder).writeInt(((Integer) data.get(414))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord207(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(415))); + (encoder).writeInt(((Integer) data.get(416))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord208(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(417))); + (encoder).writeInt(((Integer) data.get(418))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord209(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(419))); + (encoder).writeInt(((Integer) data.get(420))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord210(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(421))); + (encoder).writeInt(((Integer) data.get(422))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord211(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(423))); + (encoder).writeInt(((Integer) data.get(424))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord212(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(425))); + (encoder).writeInt(((Integer) data.get(426))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord213(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(427))); + (encoder).writeInt(((Integer) data.get(428))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord214(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(429))); + (encoder).writeInt(((Integer) data.get(430))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord215(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(431))); + (encoder).writeInt(((Integer) data.get(432))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord216(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(433))); + (encoder).writeInt(((Integer) data.get(434))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord217(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(435))); + (encoder).writeInt(((Integer) data.get(436))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord218(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(437))); + (encoder).writeInt(((Integer) data.get(438))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord219(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(439))); + (encoder).writeInt(((Integer) data.get(440))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord220(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(441))); + (encoder).writeInt(((Integer) data.get(442))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord221(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(443))); + (encoder).writeInt(((Integer) data.get(444))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord222(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(445))); + (encoder).writeInt(((Integer) data.get(446))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord223(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(447))); + (encoder).writeInt(((Integer) data.get(448))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord224(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(449))); + (encoder).writeInt(((Integer) data.get(450))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord225(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(451))); + (encoder).writeInt(((Integer) data.get(452))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord226(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(453))); + (encoder).writeInt(((Integer) data.get(454))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord227(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(455))); + (encoder).writeInt(((Integer) data.get(456))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord228(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(457))); + (encoder).writeInt(((Integer) data.get(458))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord229(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(459))); + (encoder).writeInt(((Integer) data.get(460))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord230(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(461))); + (encoder).writeInt(((Integer) data.get(462))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord231(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(463))); + (encoder).writeInt(((Integer) data.get(464))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord232(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(465))); + (encoder).writeInt(((Integer) data.get(466))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord233(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(467))); + (encoder).writeInt(((Integer) data.get(468))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord234(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(469))); + (encoder).writeInt(((Integer) data.get(470))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord235(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(471))); + (encoder).writeInt(((Integer) data.get(472))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord236(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(473))); + (encoder).writeInt(((Integer) data.get(474))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord237(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(475))); + (encoder).writeInt(((Integer) data.get(476))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord238(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(477))); + (encoder).writeInt(((Integer) data.get(478))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord239(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(479))); + (encoder).writeInt(((Integer) data.get(480))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord240(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(481))); + (encoder).writeInt(((Integer) data.get(482))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord241(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(483))); + (encoder).writeInt(((Integer) data.get(484))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord242(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(485))); + (encoder).writeInt(((Integer) data.get(486))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord243(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(487))); + (encoder).writeInt(((Integer) data.get(488))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord244(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(489))); + (encoder).writeInt(((Integer) data.get(490))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord245(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(491))); + (encoder).writeInt(((Integer) data.get(492))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord246(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(493))); + (encoder).writeInt(((Integer) data.get(494))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord247(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(495))); + (encoder).writeInt(((Integer) data.get(496))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord248(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(497))); + (encoder).writeInt(((Integer) data.get(498))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord249(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(499))); + (encoder).writeInt(((Integer) data.get(500))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord250(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(501))); + (encoder).writeInt(((Integer) data.get(502))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord251(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(503))); + (encoder).writeInt(((Integer) data.get(504))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord252(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(505))); + (encoder).writeInt(((Integer) data.get(506))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord253(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(507))); + (encoder).writeInt(((Integer) data.get(508))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord254(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(509))); + (encoder).writeInt(((Integer) data.get(510))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord255(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(511))); + (encoder).writeInt(((Integer) data.get(512))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord256(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(513))); + (encoder).writeInt(((Integer) data.get(514))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord257(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(515))); + (encoder).writeInt(((Integer) data.get(516))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord258(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(517))); + (encoder).writeInt(((Integer) data.get(518))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord259(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(519))); + (encoder).writeInt(((Integer) data.get(520))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord260(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(521))); + (encoder).writeInt(((Integer) data.get(522))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord261(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(523))); + (encoder).writeInt(((Integer) data.get(524))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord262(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(525))); + (encoder).writeInt(((Integer) data.get(526))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord263(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(527))); + (encoder).writeInt(((Integer) data.get(528))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord264(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(529))); + (encoder).writeInt(((Integer) data.get(530))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord265(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(531))); + (encoder).writeInt(((Integer) data.get(532))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord266(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(533))); + (encoder).writeInt(((Integer) data.get(534))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord267(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(535))); + (encoder).writeInt(((Integer) data.get(536))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord268(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(537))); + (encoder).writeInt(((Integer) data.get(538))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord269(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(539))); + (encoder).writeInt(((Integer) data.get(540))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord270(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(541))); + (encoder).writeInt(((Integer) data.get(542))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord271(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(543))); + (encoder).writeInt(((Integer) data.get(544))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord272(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(545))); + (encoder).writeInt(((Integer) data.get(546))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord273(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(547))); + (encoder).writeInt(((Integer) data.get(548))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord274(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(549))); + (encoder).writeInt(((Integer) data.get(550))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord275(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(551))); + (encoder).writeInt(((Integer) data.get(552))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord276(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(553))); + (encoder).writeInt(((Integer) data.get(554))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord277(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(555))); + (encoder).writeInt(((Integer) data.get(556))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord278(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(557))); + (encoder).writeInt(((Integer) data.get(558))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord279(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(559))); + (encoder).writeInt(((Integer) data.get(560))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord280(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(561))); + (encoder).writeInt(((Integer) data.get(562))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord281(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(563))); + (encoder).writeInt(((Integer) data.get(564))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord282(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(565))); + (encoder).writeInt(((Integer) data.get(566))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord283(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(567))); + (encoder).writeInt(((Integer) data.get(568))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord284(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(569))); + (encoder).writeInt(((Integer) data.get(570))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord285(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(571))); + (encoder).writeInt(((Integer) data.get(572))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord286(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(573))); + (encoder).writeInt(((Integer) data.get(574))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord287(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(575))); + (encoder).writeInt(((Integer) data.get(576))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord288(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(577))); + (encoder).writeInt(((Integer) data.get(578))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord289(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(579))); + (encoder).writeInt(((Integer) data.get(580))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord290(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(581))); + (encoder).writeInt(((Integer) data.get(582))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord291(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(583))); + (encoder).writeInt(((Integer) data.get(584))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord292(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(585))); + (encoder).writeInt(((Integer) data.get(586))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord293(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(587))); + (encoder).writeInt(((Integer) data.get(588))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord294(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(589))); + (encoder).writeInt(((Integer) data.get(590))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord295(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(591))); + (encoder).writeInt(((Integer) data.get(592))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord296(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(593))); + (encoder).writeInt(((Integer) data.get(594))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord297(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(595))); + (encoder).writeInt(((Integer) data.get(596))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord298(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(597))); + (encoder).writeInt(((Integer) data.get(598))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord299(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(599))); + (encoder).writeInt(((Integer) data.get(600))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord300(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(601))); + (encoder).writeInt(((Integer) data.get(602))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord301(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(603))); + (encoder).writeInt(((Integer) data.get(604))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord302(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(605))); + (encoder).writeInt(((Integer) data.get(606))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord303(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(607))); + (encoder).writeInt(((Integer) data.get(608))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord304(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(609))); + (encoder).writeInt(((Integer) data.get(610))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord305(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(611))); + (encoder).writeInt(((Integer) data.get(612))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord306(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(613))); + (encoder).writeInt(((Integer) data.get(614))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord307(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(615))); + (encoder).writeInt(((Integer) data.get(616))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord308(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(617))); + (encoder).writeInt(((Integer) data.get(618))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord309(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(619))); + (encoder).writeInt(((Integer) data.get(620))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord310(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(621))); + (encoder).writeInt(((Integer) data.get(622))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord311(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(623))); + (encoder).writeInt(((Integer) data.get(624))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord312(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(625))); + (encoder).writeInt(((Integer) data.get(626))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord313(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(627))); + (encoder).writeInt(((Integer) data.get(628))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord314(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(629))); + (encoder).writeInt(((Integer) data.get(630))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord315(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(631))); + (encoder).writeInt(((Integer) data.get(632))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord316(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(633))); + (encoder).writeInt(((Integer) data.get(634))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord317(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(635))); + (encoder).writeInt(((Integer) data.get(636))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord318(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(637))); + (encoder).writeInt(((Integer) data.get(638))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord319(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(639))); + (encoder).writeInt(((Integer) data.get(640))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord320(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(641))); + (encoder).writeInt(((Integer) data.get(642))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord321(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(643))); + (encoder).writeInt(((Integer) data.get(644))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord322(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(645))); + (encoder).writeInt(((Integer) data.get(646))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord323(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(647))); + (encoder).writeInt(((Integer) data.get(648))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord324(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(649))); + (encoder).writeInt(((Integer) data.get(650))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord325(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(651))); + (encoder).writeInt(((Integer) data.get(652))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord326(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(653))); + (encoder).writeInt(((Integer) data.get(654))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord327(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(655))); + (encoder).writeInt(((Integer) data.get(656))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord328(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(657))); + (encoder).writeInt(((Integer) data.get(658))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord329(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(659))); + (encoder).writeInt(((Integer) data.get(660))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord330(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(661))); + (encoder).writeInt(((Integer) data.get(662))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord331(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(663))); + (encoder).writeInt(((Integer) data.get(664))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord332(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(665))); + (encoder).writeInt(((Integer) data.get(666))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord333(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(667))); + (encoder).writeInt(((Integer) data.get(668))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord334(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(669))); + (encoder).writeInt(((Integer) data.get(670))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord335(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(671))); + (encoder).writeInt(((Integer) data.get(672))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord336(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(673))); + (encoder).writeInt(((Integer) data.get(674))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord337(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(675))); + (encoder).writeInt(((Integer) data.get(676))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord338(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(677))); + (encoder).writeInt(((Integer) data.get(678))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord339(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(679))); + (encoder).writeInt(((Integer) data.get(680))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord340(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(681))); + (encoder).writeInt(((Integer) data.get(682))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord341(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(683))); + (encoder).writeInt(((Integer) data.get(684))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord342(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(685))); + (encoder).writeInt(((Integer) data.get(686))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord343(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(687))); + (encoder).writeInt(((Integer) data.get(688))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord344(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(689))); + (encoder).writeInt(((Integer) data.get(690))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord345(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(691))); + (encoder).writeInt(((Integer) data.get(692))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord346(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(693))); + (encoder).writeInt(((Integer) data.get(694))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord347(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(695))); + (encoder).writeInt(((Integer) data.get(696))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord348(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(697))); + (encoder).writeInt(((Integer) data.get(698))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord349(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(699))); + (encoder).writeInt(((Integer) data.get(700))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord350(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(701))); + (encoder).writeInt(((Integer) data.get(702))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord351(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(703))); + (encoder).writeInt(((Integer) data.get(704))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord352(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(705))); + (encoder).writeInt(((Integer) data.get(706))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord353(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(707))); + (encoder).writeInt(((Integer) data.get(708))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord354(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(709))); + (encoder).writeInt(((Integer) data.get(710))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord355(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(711))); + (encoder).writeInt(((Integer) data.get(712))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord356(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(713))); + (encoder).writeInt(((Integer) data.get(714))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord357(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(715))); + (encoder).writeInt(((Integer) data.get(716))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord358(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(717))); + (encoder).writeInt(((Integer) data.get(718))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord359(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(719))); + (encoder).writeInt(((Integer) data.get(720))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord360(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(721))); + (encoder).writeInt(((Integer) data.get(722))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord361(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(723))); + (encoder).writeInt(((Integer) data.get(724))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord362(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(725))); + (encoder).writeInt(((Integer) data.get(726))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord363(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(727))); + (encoder).writeInt(((Integer) data.get(728))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord364(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(729))); + (encoder).writeInt(((Integer) data.get(730))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord365(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(731))); + (encoder).writeInt(((Integer) data.get(732))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord366(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(733))); + (encoder).writeInt(((Integer) data.get(734))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord367(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(735))); + (encoder).writeInt(((Integer) data.get(736))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord368(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(737))); + (encoder).writeInt(((Integer) data.get(738))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord369(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(739))); + (encoder).writeInt(((Integer) data.get(740))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord370(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(741))); + (encoder).writeInt(((Integer) data.get(742))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord371(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(743))); + (encoder).writeInt(((Integer) data.get(744))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord372(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(745))); + (encoder).writeInt(((Integer) data.get(746))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord373(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(747))); + (encoder).writeInt(((Integer) data.get(748))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord374(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(749))); + (encoder).writeInt(((Integer) data.get(750))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord375(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(751))); + (encoder).writeInt(((Integer) data.get(752))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord376(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(753))); + (encoder).writeInt(((Integer) data.get(754))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord377(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(755))); + (encoder).writeInt(((Integer) data.get(756))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord378(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(757))); + (encoder).writeInt(((Integer) data.get(758))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord379(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(759))); + (encoder).writeInt(((Integer) data.get(760))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord380(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(761))); + (encoder).writeInt(((Integer) data.get(762))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord381(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(763))); + (encoder).writeInt(((Integer) data.get(764))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord382(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(765))); + (encoder).writeInt(((Integer) data.get(766))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord383(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(767))); + (encoder).writeInt(((Integer) data.get(768))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord384(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(769))); + (encoder).writeInt(((Integer) data.get(770))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord385(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(771))); + (encoder).writeInt(((Integer) data.get(772))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord386(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(773))); + (encoder).writeInt(((Integer) data.get(774))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord387(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(775))); + (encoder).writeInt(((Integer) data.get(776))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord388(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(777))); + (encoder).writeInt(((Integer) data.get(778))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord389(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(779))); + (encoder).writeInt(((Integer) data.get(780))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord390(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(781))); + (encoder).writeInt(((Integer) data.get(782))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord391(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(783))); + (encoder).writeInt(((Integer) data.get(784))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord392(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(785))); + (encoder).writeInt(((Integer) data.get(786))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord393(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(787))); + (encoder).writeInt(((Integer) data.get(788))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord394(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(789))); + (encoder).writeInt(((Integer) data.get(790))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord395(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(791))); + (encoder).writeInt(((Integer) data.get(792))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord396(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(793))); + (encoder).writeInt(((Integer) data.get(794))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord397(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(795))); + (encoder).writeInt(((Integer) data.get(796))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord398(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(797))); + (encoder).writeInt(((Integer) data.get(798))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord399(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(799))); + (encoder).writeInt(((Integer) data.get(800))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord400(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(801))); + (encoder).writeInt(((Integer) data.get(802))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord401(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(803))); + (encoder).writeInt(((Integer) data.get(804))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord402(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(805))); + (encoder).writeInt(((Integer) data.get(806))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord403(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(807))); + (encoder).writeInt(((Integer) data.get(808))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord404(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(809))); + (encoder).writeInt(((Integer) data.get(810))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord405(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(811))); + (encoder).writeInt(((Integer) data.get(812))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord406(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(813))); + (encoder).writeInt(((Integer) data.get(814))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord407(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(815))); + (encoder).writeInt(((Integer) data.get(816))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord408(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(817))); + (encoder).writeInt(((Integer) data.get(818))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord409(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(819))); + (encoder).writeInt(((Integer) data.get(820))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord410(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(821))); + (encoder).writeInt(((Integer) data.get(822))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord411(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(823))); + (encoder).writeInt(((Integer) data.get(824))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord412(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(825))); + (encoder).writeInt(((Integer) data.get(826))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord413(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(827))); + (encoder).writeInt(((Integer) data.get(828))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord414(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(829))); + (encoder).writeInt(((Integer) data.get(830))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord415(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(831))); + (encoder).writeInt(((Integer) data.get(832))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord416(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(833))); + (encoder).writeInt(((Integer) data.get(834))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord417(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(835))); + (encoder).writeInt(((Integer) data.get(836))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord418(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(837))); + (encoder).writeInt(((Integer) data.get(838))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord419(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(839))); + (encoder).writeInt(((Integer) data.get(840))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord420(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(841))); + (encoder).writeInt(((Integer) data.get(842))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord421(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(843))); + (encoder).writeInt(((Integer) data.get(844))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord422(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(845))); + (encoder).writeInt(((Integer) data.get(846))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord423(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(847))); + (encoder).writeInt(((Integer) data.get(848))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord424(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(849))); + (encoder).writeInt(((Integer) data.get(850))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord425(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(851))); + (encoder).writeInt(((Integer) data.get(852))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord426(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(853))); + (encoder).writeInt(((Integer) data.get(854))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord427(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(855))); + (encoder).writeInt(((Integer) data.get(856))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord428(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(857))); + (encoder).writeInt(((Integer) data.get(858))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord429(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(859))); + (encoder).writeInt(((Integer) data.get(860))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord430(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(861))); + (encoder).writeInt(((Integer) data.get(862))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord431(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(863))); + (encoder).writeInt(((Integer) data.get(864))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord432(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(865))); + (encoder).writeInt(((Integer) data.get(866))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord433(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(867))); + (encoder).writeInt(((Integer) data.get(868))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord434(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(869))); + (encoder).writeInt(((Integer) data.get(870))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord435(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(871))); + (encoder).writeInt(((Integer) data.get(872))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord436(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(873))); + (encoder).writeInt(((Integer) data.get(874))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord437(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(875))); + (encoder).writeInt(((Integer) data.get(876))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord438(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(877))); + (encoder).writeInt(((Integer) data.get(878))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord439(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(879))); + (encoder).writeInt(((Integer) data.get(880))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord440(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(881))); + (encoder).writeInt(((Integer) data.get(882))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord441(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(883))); + (encoder).writeInt(((Integer) data.get(884))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord442(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(885))); + (encoder).writeInt(((Integer) data.get(886))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord443(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(887))); + (encoder).writeInt(((Integer) data.get(888))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord444(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(889))); + (encoder).writeInt(((Integer) data.get(890))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord445(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(891))); + (encoder).writeInt(((Integer) data.get(892))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord446(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(893))); + (encoder).writeInt(((Integer) data.get(894))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord447(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(895))); + (encoder).writeInt(((Integer) data.get(896))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord448(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(897))); + (encoder).writeInt(((Integer) data.get(898))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord449(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(899))); + (encoder).writeInt(((Integer) data.get(900))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord450(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(901))); + (encoder).writeInt(((Integer) data.get(902))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord451(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(903))); + (encoder).writeInt(((Integer) data.get(904))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord452(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(905))); + (encoder).writeInt(((Integer) data.get(906))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord453(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(907))); + (encoder).writeInt(((Integer) data.get(908))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord454(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(909))); + (encoder).writeInt(((Integer) data.get(910))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord455(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(911))); + (encoder).writeInt(((Integer) data.get(912))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord456(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(913))); + (encoder).writeInt(((Integer) data.get(914))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord457(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(915))); + (encoder).writeInt(((Integer) data.get(916))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord458(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(917))); + (encoder).writeInt(((Integer) data.get(918))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord459(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(919))); + (encoder).writeInt(((Integer) data.get(920))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord460(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(921))); + (encoder).writeInt(((Integer) data.get(922))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord461(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(923))); + (encoder).writeInt(((Integer) data.get(924))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord462(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(925))); + (encoder).writeInt(((Integer) data.get(926))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord463(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(927))); + (encoder).writeInt(((Integer) data.get(928))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord464(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(929))); + (encoder).writeInt(((Integer) data.get(930))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord465(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(931))); + (encoder).writeInt(((Integer) data.get(932))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord466(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(933))); + (encoder).writeInt(((Integer) data.get(934))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord467(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(935))); + (encoder).writeInt(((Integer) data.get(936))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord468(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(937))); + (encoder).writeInt(((Integer) data.get(938))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord469(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(939))); + (encoder).writeInt(((Integer) data.get(940))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord470(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(941))); + (encoder).writeInt(((Integer) data.get(942))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord471(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(943))); + (encoder).writeInt(((Integer) data.get(944))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord472(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(945))); + (encoder).writeInt(((Integer) data.get(946))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord473(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(947))); + (encoder).writeInt(((Integer) data.get(948))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord474(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(949))); + (encoder).writeInt(((Integer) data.get(950))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord475(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(951))); + (encoder).writeInt(((Integer) data.get(952))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord476(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(953))); + (encoder).writeInt(((Integer) data.get(954))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord477(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(955))); + (encoder).writeInt(((Integer) data.get(956))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord478(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(957))); + (encoder).writeInt(((Integer) data.get(958))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord479(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(959))); + (encoder).writeInt(((Integer) data.get(960))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord480(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(961))); + (encoder).writeInt(((Integer) data.get(962))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord481(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(963))); + (encoder).writeInt(((Integer) data.get(964))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord482(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(965))); + (encoder).writeInt(((Integer) data.get(966))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord483(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(967))); + (encoder).writeInt(((Integer) data.get(968))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord484(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(969))); + (encoder).writeInt(((Integer) data.get(970))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord485(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(971))); + (encoder).writeInt(((Integer) data.get(972))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord486(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(973))); + (encoder).writeInt(((Integer) data.get(974))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord487(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(975))); + (encoder).writeInt(((Integer) data.get(976))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord488(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(977))); + (encoder).writeInt(((Integer) data.get(978))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord489(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(979))); + (encoder).writeInt(((Integer) data.get(980))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord490(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(981))); + (encoder).writeInt(((Integer) data.get(982))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord491(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(983))); + (encoder).writeInt(((Integer) data.get(984))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord492(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(985))); + (encoder).writeInt(((Integer) data.get(986))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord493(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(987))); + (encoder).writeInt(((Integer) data.get(988))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord494(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(989))); + (encoder).writeInt(((Integer) data.get(990))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord495(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(991))); + (encoder).writeInt(((Integer) data.get(992))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord496(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(993))); + (encoder).writeInt(((Integer) data.get(994))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord497(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(995))); + (encoder).writeInt(((Integer) data.get(996))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord498(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(997))); + (encoder).writeInt(((Integer) data.get(998))); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldSerializeLargeRecord499(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(999))); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java new file mode 100644 index 000000000..75dda92e2 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239.java @@ -0,0 +1,116 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums_GenericSerializer_496788239 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + int valueToWrite0; + Object enumValue0 = data.get(0); + if (enumValue0 instanceof Enum) { + valueToWrite0 = ((Enum) enumValue0).ordinal(); + } else { + valueToWrite0 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).toString()); + } + (encoder).writeEnum(valueToWrite0); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + GenericEnumSymbol testEnumUnion0 = ((GenericEnumSymbol) data.get(1)); + if (testEnumUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((testEnumUnion0 instanceof GenericEnumSymbol)&&"com.linkedin.avro.fastserde.generated.avro.testEnum".equals(((GenericEnumSymbol) testEnumUnion0).getSchema().getFullName())) { + (encoder).writeIndex(1); + int valueToWrite1; + Object enumValue1 = testEnumUnion0; + if (enumValue1 instanceof Enum) { + valueToWrite1 = ((Enum) enumValue1).ordinal(); + } else { + valueToWrite1 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).toString()); + } + (encoder).writeEnum(valueToWrite1); + } + } + List testEnumArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testEnumArray0 == null)||testEnumArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testEnumArray0 .size()); + for (int counter0 = 0; (counter0 testEnumUnionArray0 = ((List ) data.get(3)); + (encoder).writeArrayStart(); + if ((testEnumUnionArray0 == null)||testEnumUnionArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testEnumUnionArray0 .size()); + for (int counter1 = 0; (counter1 ) testEnumUnionArray0).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof GenericEnumSymbol)&&"com.linkedin.avro.fastserde.generated.avro.testEnum".equals(((GenericEnumSymbol) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + int valueToWrite3; + Object enumValue3 = union0; + if (enumValue3 instanceof Enum) { + valueToWrite3 = ((Enum) enumValue3).ordinal(); + } else { + valueToWrite3 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue3).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue3).toString()); + } + (encoder).writeEnum(valueToWrite3); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java new file mode 100644 index 000000000..a5a104b23 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146.java @@ -0,0 +1,88 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed_GenericSerializer_1473954146 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteGenericRecordWithFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + GenericFixed testFixedUnion0 = ((GenericFixed) data.get(1)); + if (testFixedUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((testFixedUnion0 instanceof GenericFixed)&&"com.linkedin.avro.fastserde.generated.avro.testFixed".equals(((GenericFixed) testFixedUnion0).getSchema().getFullName())) { + (encoder).writeIndex(1); + (encoder).writeFixed(((GenericFixed) testFixedUnion0).bytes()); + } + } + List testFixedArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testFixedArray0 == null)||testFixedArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testFixedArray0 .size()); + for (int counter0 = 0; (counter0 testFixedUnionArray0 = ((List ) data.get(3)); + (encoder).writeArrayStart(); + if ((testFixedUnionArray0 == null)||testFixedUnionArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testFixedUnionArray0 .size()); + for (int counter1 = 0; (counter1 ) testFixedUnionArray0).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof GenericFixed)&&"com.linkedin.avro.fastserde.generated.avro.testFixed".equals(((GenericFixed) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + (encoder).writeFixed(((GenericFixed) union0).bytes()); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java new file mode 100644 index 000000000..c0d52b27a --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050.java @@ -0,0 +1,70 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion_GenericSerializer_1076995050 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteMultipleChoiceUnion0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object union0 = ((Object) data.get(0)); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } else { + if (union0 instanceof CharSequence) { + (encoder).writeIndex(2); + if (((CharSequence) union0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) union0))); + } else { + (encoder).writeString(((CharSequence) union0).toString()); + } + } else { + if (union0 instanceof Integer) { + (encoder).writeIndex(3); + (encoder).writeInt(((Integer) union0)); + } + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java new file mode 100644 index 000000000..d35a71b2f --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553.java @@ -0,0 +1,157 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.nio.ByteBuffer; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWritePrimitives_GenericSerializer_538850553 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Integer testIntUnion0 = ((Integer) data.get(1)); + if (testIntUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeInt(((Integer) testIntUnion0)); + } + Integer testFlippedIntUnion0 = ((Integer) data.get(2)); + if (testFlippedIntUnion0 == null) { + (encoder).writeIndex(1); + (encoder).writeNull(); + } else { + (encoder).writeIndex(0); + (encoder).writeInt(((Integer) testFlippedIntUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(3)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(3)))); + } else { + (encoder).writeString(((CharSequence) data.get(3)).toString()); + } + CharSequence testStringUnion0 = ((CharSequence) data.get(4)); + if (testStringUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testStringUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringUnion0))); + } else { + (encoder).writeString(((CharSequence) testStringUnion0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives2(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeLong(((Long) data.get(5))); + Long testLongUnion0 = ((Long) data.get(6)); + if (testLongUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeLong(((Long) testLongUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives3(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeDouble(((Double) data.get(7))); + Double testDoubleUnion0 = ((Double) data.get(8)); + if (testDoubleUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeDouble(((Double) testDoubleUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives4(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFloat(((Float) data.get(9))); + Float testFloatUnion0 = ((Float) data.get(10)); + if (testFloatUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeFloat(((Float) testFloatUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives5(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeBoolean(((Boolean) data.get(11))); + Boolean testBooleanUnion0 = ((Boolean) data.get(12)); + if (testBooleanUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeBoolean(((Boolean) testBooleanUnion0)); + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWritePrimitives6(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeBytes(((ByteBuffer) data.get(13))); + ByteBuffer testBytesUnion0 = ((ByteBuffer) data.get(14)); + if (testBytesUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeBytes(((ByteBuffer) testBytesUnion0)); + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java new file mode 100644 index 000000000..5995738cc --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex_GenericSerializer_31578414 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteRightUnionIndex0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object union_field0 = ((Object) data.get(0)); + if (union_field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record1".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord10(((IndexedRecord) union_field0), (encoder), (customization)); + } else { + if ((union_field0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record2".equals(((IndexedRecord) union_field0).getSchema().getFullName())) { + (encoder).writeIndex(2); + serializeRecord20(((IndexedRecord) union_field0), (encoder), (customization)); + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeRecord10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + } + + @SuppressWarnings("unchecked") + public void serializeRecord20(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java new file mode 100644 index 000000000..102fe730f --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347.java @@ -0,0 +1,158 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField_GenericSerializer_1348736347 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List recordsArray0 = ((List ) data.get(0)); + (encoder).writeArrayStart(); + if ((recordsArray0 == null)||recordsArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsArray0 .size()); + for (int counter0 = 0; (counter0 ) recordsArray0).get(counter0); + serializeSubRecord0(subRecord0, (encoder), (customization)); + } + } + (encoder).writeArrayEnd(); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map recordsMap0 = ((Map ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMap0); + } + (encoder).writeMapStart(); + if ((recordsMap0 == null)||recordsMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsMap0 .size()); + for (CharSequence key0 : ((Map ) recordsMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord subRecord1 = null; + subRecord1 = ((Map ) recordsMap0).get(key0); + serializeSubRecord0(subRecord1, (encoder), (customization)); + } + } + (encoder).writeMapEnd(); + List recordsArrayUnion0 = ((List ) data.get(2)); + if (recordsArrayUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsArrayUnion0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) recordsArrayUnion0) == null)||((List ) recordsArrayUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) recordsArrayUnion0).size()); + for (int counter1 = 0; (counter1 <((List ) recordsArrayUnion0).size()); counter1 ++) { + (encoder).startItem(); + IndexedRecord union0 = null; + union0 = ((List )((List ) recordsArrayUnion0)).get(counter1); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map recordsMapUnion0 = ((Map ) data.get(3)); + if (recordsMapUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsMapUnion0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map ) recordsMapUnion0)); + } + (encoder).writeMapStart(); + if ((((Map ) recordsMapUnion0) == null)||((Map ) recordsMapUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map ) recordsMapUnion0).size()); + for (CharSequence key1 : ((Map )((Map ) recordsMapUnion0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + IndexedRecord union1 = null; + union1 = ((Map )((Map ) recordsMapUnion0)).get(key1); + if (union1 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java new file mode 100644 index 000000000..169a3c821 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373.java @@ -0,0 +1,230 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField_GenericSerializer_1813582373 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List> recordsArrayMap0 = ((List> ) data.get(0)); + (encoder).writeArrayStart(); + if ((recordsArrayMap0 == null)||recordsArrayMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsArrayMap0 .size()); + for (int counter0 = 0; (counter0 map0 = null; + map0 = ((List> ) recordsArrayMap0).get(counter0); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map0); + } + (encoder).writeMapStart(); + if ((map0 == null)||map0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(map0 .size()); + for (CharSequence key0 : ((Map ) map0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord union0 = null; + union0 = ((Map ) map0).get(key0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + (encoder).writeArrayEnd(); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(data, (encoder), (customization)); + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map> recordsMapArray0 = ((Map> ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(recordsMapArray0); + } + (encoder).writeMapStart(); + if ((recordsMapArray0 == null)||recordsMapArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(recordsMapArray0 .size()); + for (CharSequence key1 : ((Map> ) recordsMapArray0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + List array0 = null; + array0 = ((Map> ) recordsMapArray0).get(key1); + (encoder).writeArrayStart(); + if ((array0 == null)||array0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array0 .size()); + for (int counter1 = 0; (counter1 ) array0).get(counter1); + if (union1 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union1 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union1).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union1), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + (encoder).writeMapEnd(); + List> recordsArrayMapUnion0 = ((List> ) data.get(2)); + if (recordsArrayMapUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsArrayMapUnion0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List> ) recordsArrayMapUnion0) == null)||((List> ) recordsArrayMapUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List> ) recordsArrayMapUnion0).size()); + for (int counter2 = 0; (counter2 <((List> ) recordsArrayMapUnion0).size()); counter2 ++) { + (encoder).startItem(); + Map map1 = null; + map1 = ((List> )((List> ) recordsArrayMapUnion0)).get(counter2); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(map1); + } + (encoder).writeMapStart(); + if ((map1 == null)||map1 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(map1 .size()); + for (CharSequence key2 : ((Map ) map1).keySet()) { + (encoder).startItem(); + (encoder).writeString(key2); + IndexedRecord union2 = null; + union2 = ((Map ) map1).get(key2); + if (union2 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union2 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union2).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union2), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + } + (encoder).writeArrayEnd(); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordComplexCollectionsField1(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map> recordsMapArrayUnion0 = ((Map> ) data.get(3)); + if (recordsMapArrayUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (recordsMapArrayUnion0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map> ) recordsMapArrayUnion0)); + } + (encoder).writeMapStart(); + if ((((Map> ) recordsMapArrayUnion0) == null)||((Map> ) recordsMapArrayUnion0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map> ) recordsMapArrayUnion0).size()); + for (CharSequence key3 : ((Map> )((Map> ) recordsMapArrayUnion0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key3); + List array1 = null; + array1 = ((Map> )((Map> ) recordsMapArrayUnion0)).get(key3); + (encoder).writeArrayStart(); + if ((array1 == null)||array1 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array1 .size()); + for (int counter3 = 0; (counter3 ) array1).get(counter3); + if (union3 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union3 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) union3).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) union3), (encoder), (customization)); + } + } + } + } + (encoder).writeArrayEnd(); + } + } + (encoder).writeMapEnd(); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java new file mode 100644 index 000000000..d8465c6d9 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027.java @@ -0,0 +1,77 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastGenericSerializerGeneratorTest_shouldWriteSubRecordField_GenericSerializer_652769027 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + IndexedRecord record0 = ((IndexedRecord) data.get(0)); + if (record0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((record0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.subRecord".equals(((IndexedRecord) record0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeSubRecord0(((IndexedRecord) record0), (encoder), (customization)); + } + } + serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeSubRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence subField0 = ((CharSequence) data.get(0)); + if (subField0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) subField0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) subField0))); + } else { + (encoder).writeString(((CharSequence) subField0).toString()); + } + } + } + + @SuppressWarnings("unchecked") + private void serialize_FastGenericSerializerGeneratorTest_shouldWriteSubRecordField0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + IndexedRecord record10 = ((IndexedRecord) data.get(1)); + serializeSubRecord0(record10, (encoder), (customization)); + CharSequence field0 = ((CharSequence) data.get(2)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeEnums_GenericSerializer_957378572.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeEnums_GenericSerializer_957378572.java new file mode 100644 index 000000000..f1708b379 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeEnums_GenericSerializer_957378572.java @@ -0,0 +1,95 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericEnumSymbol; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeEnums_GenericSerializer_957378572 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + int valueToWrite0; + Object enumValue0 = data.get(0); + if (enumValue0 instanceof Enum) { + valueToWrite0 = ((Enum) enumValue0).ordinal(); + } else { + valueToWrite0 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue0).toString()); + } + (encoder).writeEnum(valueToWrite0); + serialize_FastSerdeEnums0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeEnums0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List arrayOfEnums0 = ((List ) data.get(1)); + if (arrayOfEnums0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (arrayOfEnums0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) arrayOfEnums0) == null)||((List ) arrayOfEnums0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) arrayOfEnums0).size()); + for (int counter0 = 0; (counter0 <((List ) arrayOfEnums0).size()); counter0 ++) { + (encoder).startItem(); + int valueToWrite1; + Object enumValue1 = ((List ) arrayOfEnums0).get(counter0); + if (enumValue1 instanceof Enum) { + valueToWrite1 = ((Enum) enumValue1).ordinal(); + } else { + valueToWrite1 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue1).toString()); + } + (encoder).writeEnum(valueToWrite1); + } + } + (encoder).writeArrayEnd(); + } + } + Map mapOfEnums0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfEnums0); + } + (encoder).writeMapStart(); + if ((mapOfEnums0 == null)||mapOfEnums0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfEnums0 .size()); + for (CharSequence key0 : ((Map ) mapOfEnums0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + int valueToWrite2; + Object enumValue2 = mapOfEnums0 .get(key0); + if (enumValue2 instanceof Enum) { + valueToWrite2 = ((Enum) enumValue2).ordinal(); + } else { + valueToWrite2 = ((org.apache.avro.generic.GenericData.EnumSymbol) enumValue2).getSchema().getEnumOrdinal(((org.apache.avro.generic.GenericData.EnumSymbol) enumValue2).toString()); + } + (encoder).writeEnum(valueToWrite2); + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeFixed_GenericSerializer_504108934.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeFixed_GenericSerializer_504108934.java new file mode 100644 index 000000000..791de0b60 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeFixed_GenericSerializer_504108934.java @@ -0,0 +1,74 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.GenericFixed; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeFixed_GenericSerializer_504108934 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeFixed(((GenericFixed) data.get(0)).bytes()); + serialize_FastSerdeFixed0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeFixed0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List arrayOfFixed0 = ((List ) data.get(1)); + if (arrayOfFixed0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (arrayOfFixed0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) arrayOfFixed0) == null)||((List ) arrayOfFixed0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) arrayOfFixed0).size()); + for (int counter0 = 0; (counter0 <((List ) arrayOfFixed0).size()); counter0 ++) { + (encoder).startItem(); + (encoder).writeFixed(((GenericFixed)((List ) arrayOfFixed0).get(counter0)).bytes()); + } + } + (encoder).writeArrayEnd(); + } + } + Map mapOfFixed0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfFixed0); + } + (encoder).writeMapStart(); + if ((mapOfFixed0 == null)||mapOfFixed0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfFixed0 .size()); + for (CharSequence key0 : ((Map ) mapOfFixed0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + (encoder).writeFixed(((GenericFixed) mapOfFixed0 .get(key0)).bytes()); + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeLogicalTypesDefined_GenericSerializer_229156053.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeLogicalTypesDefined_GenericSerializer_229156053.java new file mode 100644 index 000000000..fe53ba97e --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeLogicalTypesDefined_GenericSerializer_229156053.java @@ -0,0 +1,80 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.time.Instant; +import java.time.LocalDate; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.Conversions; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class FastSerdeLogicalTypesDefined_GenericSerializer_229156053 + implements FastSerializer +{ + + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final Conversions.DecimalConversion conversion_decimal = new Conversions.DecimalConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesDefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesDefined0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object convertedValue0 = data.get(0); + convertedValue0 = Conversions.convertToRawType(convertedValue0, this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis); + (encoder).writeInt(((Integer) convertedValue0)); + serialize_FastSerdeLogicalTypesDefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesDefined0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object convertedValue1 = data.get(1); + convertedValue1 = Conversions.convertToRawType(convertedValue1, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue1)); + List arrayOfUnionOfDateAndTimestampMillis0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((arrayOfUnionOfDateAndTimestampMillis0 == null)||arrayOfUnionOfDateAndTimestampMillis0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(arrayOfUnionOfDateAndTimestampMillis0 .size()); + for (int counter0 = 0; (counter0 ) arrayOfUnionOfDateAndTimestampMillis0).get(counter0); + if (union0 instanceof LocalDate) { + (encoder).writeIndex(0); + Object convertedValue2 = union0; + convertedValue2 = Conversions.convertToRawType(convertedValue2, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue2)); + } else { + if (union0 instanceof Instant) { + (encoder).writeIndex(1); + Object convertedValue3 = union0; + convertedValue3 = Conversions.convertToRawType(convertedValue3, this.logicalTypeSchema_1074306973, this.logicalTypeSchema_1074306973 .getLogicalType(), this.conversion_timestamp_millis); + (encoder).writeLong(((Long) convertedValue3)); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeLogicalTypesDefined_SpecificSerializer_229156053.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeLogicalTypesDefined_SpecificSerializer_229156053.java new file mode 100644 index 000000000..3b1d12908 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeLogicalTypesDefined_SpecificSerializer_229156053.java @@ -0,0 +1,80 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.time.Instant; +import java.time.LocalDate; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesDefined; +import org.apache.avro.Conversions; +import org.apache.avro.Schema; +import org.apache.avro.io.Encoder; + +public class FastSerdeLogicalTypesDefined_SpecificSerializer_229156053 + implements FastSerializer +{ + + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final Conversions.DecimalConversion conversion_decimal = new Conversions.DecimalConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + + public void serialize(FastSerdeLogicalTypesDefined data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesDefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesDefined0(FastSerdeLogicalTypesDefined data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object convertedValue0 = data.get(0); + convertedValue0 = Conversions.convertToRawType(convertedValue0, this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis); + (encoder).writeInt(((Integer) convertedValue0)); + serialize_FastSerdeLogicalTypesDefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesDefined0(FastSerdeLogicalTypesDefined data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object convertedValue1 = data.get(1); + convertedValue1 = Conversions.convertToRawType(convertedValue1, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue1)); + List arrayOfUnionOfDateAndTimestampMillis0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((arrayOfUnionOfDateAndTimestampMillis0 == null)||arrayOfUnionOfDateAndTimestampMillis0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(arrayOfUnionOfDateAndTimestampMillis0 .size()); + for (int counter0 = 0; (counter0 ) arrayOfUnionOfDateAndTimestampMillis0).get(counter0); + if (union0 instanceof LocalDate) { + (encoder).writeIndex(0); + Object convertedValue2 = union0; + convertedValue2 = Conversions.convertToRawType(convertedValue2, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue2)); + } else { + if (union0 instanceof Instant) { + (encoder).writeIndex(1); + Object convertedValue3 = union0; + convertedValue3 = Conversions.convertToRawType(convertedValue3, this.logicalTypeSchema_1074306973, this.logicalTypeSchema_1074306973 .getLogicalType(), this.conversion_timestamp_millis); + (encoder).writeLong(((Long) convertedValue3)); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeLogicalTypesTest1_GenericSerializer_1007574890.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeLogicalTypesTest1_GenericSerializer_1007574890.java new file mode 100644 index 000000000..e8dac41b7 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeLogicalTypesTest1_GenericSerializer_1007574890.java @@ -0,0 +1,341 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.math.BigDecimal; +import java.nio.ByteBuffer; +import java.time.Instant; +import java.time.LocalDate; +import java.time.LocalTime; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.api.PrimitiveIntList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.Conversions; +import org.apache.avro.Schema; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastSerdeLogicalTypesTest1_GenericSerializer_1007574890 + implements FastSerializer +{ + + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final Conversions.DecimalConversion conversion_decimal = new Conversions.DecimalConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + private final Schema logicalTypeSchema_120893213 = Schema.parse("{\"type\":\"bytes\",\"logicalType\":\"decimal\",\"precision\":4,\"scale\":2}"); + private final Schema logicalTypeSchema__1252781617 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-micros\"}"); + private final Schema logicalTypeSchema__1515894331 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"time-micros\"}"); + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesTest10(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesTest10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object unionOfArrayAndMap0 = ((Object) data.get(0)); + if (unionOfArrayAndMap0 instanceof List) { + (encoder).writeIndex(0); + (encoder).writeArrayStart(); + if ((((List ) unionOfArrayAndMap0) == null)||((List ) unionOfArrayAndMap0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) unionOfArrayAndMap0).size()); + Object array0 = ((List ) unionOfArrayAndMap0); + if (array0 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList0 = ((PrimitiveIntList) array0); + for (int counter0 = 0; (counter0 ) unionOfArrayAndMap0).size()); counter1 ++) { + (encoder).startItem(); + Object convertedValue1 = ((List ) unionOfArrayAndMap0).get(counter1); + convertedValue1 = Conversions.convertToRawType(convertedValue1, this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis); + (encoder).writeInt(((Integer) convertedValue1)); + } + } + } + (encoder).writeArrayEnd(); + } else { + if (unionOfArrayAndMap0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map ) unionOfArrayAndMap0)); + } + (encoder).writeMapStart(); + if ((((Map ) unionOfArrayAndMap0) == null)||((Map ) unionOfArrayAndMap0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map ) unionOfArrayAndMap0).size()); + for (CharSequence key0 : ((Map )((Map ) unionOfArrayAndMap0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + Object convertedValue2 = ((Map ) unionOfArrayAndMap0).get(key0); + convertedValue2 = Conversions.convertToRawType(convertedValue2, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue2)); + } + } + (encoder).writeMapEnd(); + } + } + serialize_FastSerdeLogicalTypesTest10(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest11(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest12(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest13(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest14(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest15(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesTest10(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map mapOfUnionsOfDateAndTimestampMillis0 = ((Map ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfUnionsOfDateAndTimestampMillis0); + } + (encoder).writeMapStart(); + if ((mapOfUnionsOfDateAndTimestampMillis0 == null)||mapOfUnionsOfDateAndTimestampMillis0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfUnionsOfDateAndTimestampMillis0 .size()); + for (CharSequence key1 : ((Map ) mapOfUnionsOfDateAndTimestampMillis0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + Object union0 = null; + union0 = ((Map ) mapOfUnionsOfDateAndTimestampMillis0).get(key1); + if (union0 instanceof LocalDate) { + (encoder).writeIndex(0); + Object convertedValue3 = union0; + convertedValue3 = Conversions.convertToRawType(convertedValue3, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue3)); + } else { + if (union0 instanceof Instant) { + (encoder).writeIndex(1); + Object convertedValue4 = union0; + convertedValue4 = Conversions.convertToRawType(convertedValue4, this.logicalTypeSchema_1074306973, this.logicalTypeSchema_1074306973 .getLogicalType(), this.conversion_timestamp_millis); + (encoder).writeLong(((Long) convertedValue4)); + } + } + } + } + (encoder).writeMapEnd(); + Map timestampMillisMap0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(timestampMillisMap0); + } + (encoder).writeMapStart(); + if ((timestampMillisMap0 == null)||timestampMillisMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(timestampMillisMap0 .size()); + for (CharSequence key2 : ((Map ) timestampMillisMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key2); + Object convertedValue5 = timestampMillisMap0 .get(key2); + convertedValue5 = Conversions.convertToRawType(convertedValue5, this.logicalTypeSchema_1074306973, this.logicalTypeSchema_1074306973 .getLogicalType(), this.conversion_timestamp_millis); + (encoder).writeLong(((Long) convertedValue5)); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesTest11(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List nullableArrayOfDates0 = ((List ) data.get(3)); + if (nullableArrayOfDates0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (nullableArrayOfDates0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) nullableArrayOfDates0) == null)||((List ) nullableArrayOfDates0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) nullableArrayOfDates0).size()); + Object array1 = ((List ) nullableArrayOfDates0); + if (array1 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList1 = ((PrimitiveIntList) array1); + for (int counter2 = 0; (counter2 ) nullableArrayOfDates0).size()); counter3 ++) { + (encoder).startItem(); + Object convertedValue7 = ((List ) nullableArrayOfDates0).get(counter3); + convertedValue7 = Conversions.convertToRawType(convertedValue7, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue7)); + } + } + } + (encoder).writeArrayEnd(); + } + } + List arrayOfDates0 = ((List ) data.get(4)); + (encoder).writeArrayStart(); + if ((arrayOfDates0 == null)||arrayOfDates0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(arrayOfDates0 .size()); + Object array2 = arrayOfDates0; + if (array2 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList2 = ((PrimitiveIntList) array2); + for (int counter4 = 0; (counter4 +{ + + private final org.apache.avro.data.TimeConversions.DateConversion conversion_date = new org.apache.avro.data.TimeConversions.DateConversion(); + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimeMillisConversion conversion_time_millis = new org.apache.avro.data.TimeConversions.TimeMillisConversion(); + private final Conversions.DecimalConversion conversion_decimal = new Conversions.DecimalConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMillisConversion conversion_timestamp_millis = new org.apache.avro.data.TimeConversions.TimestampMillisConversion(); + private final Schema logicalTypeSchema__419105534 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"time-millis\"}"); + private final Schema logicalTypeSchema__59052268 = Schema.parse("{\"type\":\"int\",\"logicalType\":\"date\"}"); + private final Schema logicalTypeSchema_1074306973 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-millis\"}"); + private final Schema logicalTypeSchema_120893213 = Schema.parse("{\"type\":\"bytes\",\"logicalType\":\"decimal\",\"precision\":4,\"scale\":2}"); + private final Schema logicalTypeSchema__1252781617 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"timestamp-micros\"}"); + private final Schema logicalTypeSchema__1515894331 = Schema.parse("{\"type\":\"long\",\"logicalType\":\"time-micros\"}"); + + public void serialize(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesTest10(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesTest10(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object unionOfArrayAndMap0 = ((Object) data.get(0)); + if (unionOfArrayAndMap0 instanceof List) { + (encoder).writeIndex(0); + (encoder).writeArrayStart(); + if ((((List ) unionOfArrayAndMap0) == null)||((List ) unionOfArrayAndMap0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) unionOfArrayAndMap0).size()); + Object array0 = ((List ) unionOfArrayAndMap0); + if (array0 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList0 = ((PrimitiveIntList) array0); + for (int counter0 = 0; (counter0 ) unionOfArrayAndMap0).size()); counter1 ++) { + (encoder).startItem(); + Object convertedValue1 = ((List ) unionOfArrayAndMap0).get(counter1); + convertedValue1 = Conversions.convertToRawType(convertedValue1, this.logicalTypeSchema__419105534, this.logicalTypeSchema__419105534 .getLogicalType(), this.conversion_time_millis); + (encoder).writeInt(((Integer) convertedValue1)); + } + } + } + (encoder).writeArrayEnd(); + } else { + if (unionOfArrayAndMap0 instanceof Map) { + (encoder).writeIndex(1); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(((Map ) unionOfArrayAndMap0)); + } + (encoder).writeMapStart(); + if ((((Map ) unionOfArrayAndMap0) == null)||((Map ) unionOfArrayAndMap0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((Map ) unionOfArrayAndMap0).size()); + for (CharSequence key0 : ((Map )((Map ) unionOfArrayAndMap0)).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + Object convertedValue2 = ((Map ) unionOfArrayAndMap0).get(key0); + convertedValue2 = Conversions.convertToRawType(convertedValue2, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue2)); + } + } + (encoder).writeMapEnd(); + } + } + serialize_FastSerdeLogicalTypesTest10(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest11(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest12(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest13(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest14(data, (encoder), (customization)); + serialize_FastSerdeLogicalTypesTest15(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesTest10(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Map mapOfUnionsOfDateAndTimestampMillis0 = ((Map ) data.get(1)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(mapOfUnionsOfDateAndTimestampMillis0); + } + (encoder).writeMapStart(); + if ((mapOfUnionsOfDateAndTimestampMillis0 == null)||mapOfUnionsOfDateAndTimestampMillis0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(mapOfUnionsOfDateAndTimestampMillis0 .size()); + for (CharSequence key1 : ((Map ) mapOfUnionsOfDateAndTimestampMillis0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key1); + Object union0 = null; + union0 = ((Map ) mapOfUnionsOfDateAndTimestampMillis0).get(key1); + if (union0 instanceof LocalDate) { + (encoder).writeIndex(0); + Object convertedValue3 = union0; + convertedValue3 = Conversions.convertToRawType(convertedValue3, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue3)); + } else { + if (union0 instanceof Instant) { + (encoder).writeIndex(1); + Object convertedValue4 = union0; + convertedValue4 = Conversions.convertToRawType(convertedValue4, this.logicalTypeSchema_1074306973, this.logicalTypeSchema_1074306973 .getLogicalType(), this.conversion_timestamp_millis); + (encoder).writeLong(((Long) convertedValue4)); + } + } + } + } + (encoder).writeMapEnd(); + Map timestampMillisMap0 = ((Map ) data.get(2)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(timestampMillisMap0); + } + (encoder).writeMapStart(); + if ((timestampMillisMap0 == null)||timestampMillisMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(timestampMillisMap0 .size()); + for (CharSequence key2 : ((Map ) timestampMillisMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key2); + Object convertedValue5 = timestampMillisMap0 .get(key2); + convertedValue5 = Conversions.convertToRawType(convertedValue5, this.logicalTypeSchema_1074306973, this.logicalTypeSchema_1074306973 .getLogicalType(), this.conversion_timestamp_millis); + (encoder).writeLong(((Long) convertedValue5)); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesTest11(FastSerdeLogicalTypesTest1 data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List nullableArrayOfDates0 = ((List ) data.get(3)); + if (nullableArrayOfDates0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (nullableArrayOfDates0 instanceof List) { + (encoder).writeIndex(1); + (encoder).writeArrayStart(); + if ((((List ) nullableArrayOfDates0) == null)||((List ) nullableArrayOfDates0).isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(((List ) nullableArrayOfDates0).size()); + Object array1 = ((List ) nullableArrayOfDates0); + if (array1 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList1 = ((PrimitiveIntList) array1); + for (int counter2 = 0; (counter2 ) nullableArrayOfDates0).size()); counter3 ++) { + (encoder).startItem(); + Object convertedValue7 = ((List ) nullableArrayOfDates0).get(counter3); + convertedValue7 = Conversions.convertToRawType(convertedValue7, this.logicalTypeSchema__59052268, this.logicalTypeSchema__59052268 .getLogicalType(), this.conversion_date); + (encoder).writeInt(((Integer) convertedValue7)); + } + } + } + (encoder).writeArrayEnd(); + } + } + List arrayOfDates0 = ((List ) data.get(4)); + (encoder).writeArrayStart(); + if ((arrayOfDates0 == null)||arrayOfDates0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(arrayOfDates0 .size()); + Object array2 = arrayOfDates0; + if (array2 instanceof PrimitiveIntList) { + PrimitiveIntList primitiveList2 = ((PrimitiveIntList) array2); + for (int counter4 = 0; (counter4 +{ + + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.Conversions.DecimalConversion conversion_decimal = new org.apache.avro.Conversions.DecimalConversion(); + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesUndefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesUndefined0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastSerdeLogicalTypesUndefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesUndefined0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(1))); + List arrayOfUnionOfDateAndTimestampMillis0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((arrayOfUnionOfDateAndTimestampMillis0 == null)||arrayOfUnionOfDateAndTimestampMillis0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(arrayOfUnionOfDateAndTimestampMillis0 .size()); + for (int counter0 = 0; (counter0 ) arrayOfUnionOfDateAndTimestampMillis0).get(counter0); + if (union0 instanceof Integer) { + (encoder).writeIndex(0); + (encoder).writeInt(((Integer) union0)); + } else { + if (union0 instanceof Long) { + (encoder).writeIndex(1); + (encoder).writeLong(((Long) union0)); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeLogicalTypesUndefined_SpecificSerializer_1982763418.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeLogicalTypesUndefined_SpecificSerializer_1982763418.java new file mode 100644 index 000000000..1fcd0d0d5 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastSerdeLogicalTypesUndefined_SpecificSerializer_1982763418.java @@ -0,0 +1,62 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import com.linkedin.avro.fastserde.generated.avro.FastSerdeLogicalTypesUndefined; +import org.apache.avro.io.Encoder; + +public class FastSerdeLogicalTypesUndefined_SpecificSerializer_1982763418 + implements FastSerializer +{ + + private final org.apache.avro.data.TimeConversions.TimeMicrosConversion conversion_time_micros = new org.apache.avro.data.TimeConversions.TimeMicrosConversion(); + private final org.apache.avro.data.TimeConversions.TimestampMicrosConversion conversion_timestamp_micros = new org.apache.avro.data.TimeConversions.TimestampMicrosConversion(); + private final org.apache.avro.Conversions.DecimalConversion conversion_decimal = new org.apache.avro.Conversions.DecimalConversion(); + + public void serialize(FastSerdeLogicalTypesUndefined data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastSerdeLogicalTypesUndefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastSerdeLogicalTypesUndefined0(FastSerdeLogicalTypesUndefined data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(0))); + serialize_FastSerdeLogicalTypesUndefined0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastSerdeLogicalTypesUndefined0(FastSerdeLogicalTypesUndefined data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeInt(((Integer) data.get(1))); + List arrayOfUnionOfDateAndTimestampMillis0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((arrayOfUnionOfDateAndTimestampMillis0 == null)||arrayOfUnionOfDateAndTimestampMillis0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(arrayOfUnionOfDateAndTimestampMillis0 .size()); + for (int counter0 = 0; (counter0 ) arrayOfUnionOfDateAndTimestampMillis0).get(counter0); + if (union0 instanceof Integer) { + (encoder).writeIndex(0); + (encoder).writeInt(((Integer) union0)); + } else { + if (union0 instanceof Long) { + (encoder).writeIndex(1); + (encoder).writeLong(((Long) union0)); + } + } + } + } + (encoder).writeArrayEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java new file mode 100644 index 000000000..21c4255aa --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569.java @@ -0,0 +1,97 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyInReaderSchemaTest_GenericSerializer_205569 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyInReaderSchemaTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence testUnionString0 = ((CharSequence) data.get(1)); + if (testUnionString0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testUnionString0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testUnionString0))); + } else { + (encoder).writeString(((CharSequence) testUnionString0).toString()); + } + } + List testStringArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testStringArray0 == null)||testStringArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringArray0 .size()); + for (int counter0 = 0; (counter0 testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } + (encoder).writeMapStart(); + if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringMap0 .size()); + for (CharSequence key0 : ((Map ) testStringMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) testStringMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) testStringMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java new file mode 100644 index 000000000..7519c0d80 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985.java @@ -0,0 +1,97 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class FastStringableTest_javaStringPropertyTest_GenericSerializer_1110978985 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeFastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeFastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((CharSequence) data.get(0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) data.get(0)))); + } else { + (encoder).writeString(((CharSequence) data.get(0)).toString()); + } + serialize_FastStringableTest_javaStringPropertyTest0(data, (encoder), (customization)); + serialize_FastStringableTest_javaStringPropertyTest1(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_FastStringableTest_javaStringPropertyTest0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence testUnionString0 = ((CharSequence) data.get(1)); + if (testUnionString0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) testUnionString0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testUnionString0))); + } else { + (encoder).writeString(((CharSequence) testUnionString0).toString()); + } + } + List testStringArray0 = ((List ) data.get(2)); + (encoder).writeArrayStart(); + if ((testStringArray0 == null)||testStringArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringArray0 .size()); + for (int counter0 = 0; (counter0 testStringMap0 = ((Map ) data.get(3)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(testStringMap0); + } + (encoder).writeMapStart(); + if ((testStringMap0 == null)||testStringMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(testStringMap0 .size()); + for (CharSequence key0 : ((Map ) testStringMap0).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + if (((CharSequence) testStringMap0 .get(key0)) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) testStringMap0 .get(key0)))); + } else { + (encoder).writeString(((CharSequence) testStringMap0 .get(key0)).toString()); + } + } + } + (encoder).writeMapEnd(); + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/Map_of_UNION_GenericSerializer_2140000109.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/Map_of_UNION_GenericSerializer_2140000109.java new file mode 100644 index 000000000..1b5d3fa2e --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/Map_of_UNION_GenericSerializer_2140000109.java @@ -0,0 +1,65 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Map_of_UNION_GenericSerializer_2140000109 + implements FastSerializer> +{ + + + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } + (encoder).writeMapStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (CharSequence key0 : ((Map ) data).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord union0 = null; + union0 = ((Map ) data).get(key0); + if (union0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if ((union0 instanceof IndexedRecord)&&"com.linkedin.avro.fastserde.generated.avro.record".equals(((IndexedRecord) union0).getSchema().getFullName())) { + (encoder).writeIndex(1); + serializeRecord0(((IndexedRecord) union0), (encoder), (customization)); + } + } + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/Map_of_record_GenericSerializer_1677529043.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/Map_of_record_GenericSerializer_1677529043.java new file mode 100644 index 000000000..a5cb9d794 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/Map_of_record_GenericSerializer_1677529043.java @@ -0,0 +1,57 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class Map_of_record_GenericSerializer_1677529043 + implements FastSerializer> +{ + + + public void serialize(Map data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(data); + } + (encoder).writeMapStart(); + if ((data == null)||data.isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(data.size()); + for (CharSequence key0 : ((Map ) data).keySet()) { + (encoder).startItem(); + (encoder).writeString(key0); + IndexedRecord record0 = null; + record0 = ((Map ) data).get(key0); + serializeRecord0(record0, (encoder), (customization)); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + public void serializeRecord0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + CharSequence field0 = ((CharSequence) data.get(0)); + if (field0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + if (((CharSequence) field0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) field0))); + } else { + (encoder).writeString(((CharSequence) field0).toString()); + } + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/StringableRecord_SpecificSerializer_842267318.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/StringableRecord_SpecificSerializer_842267318.java new file mode 100644 index 000000000..c716c8c9c --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/StringableRecord_SpecificSerializer_842267318.java @@ -0,0 +1,159 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.File; +import java.io.IOException; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.net.URI; +import java.net.URL; +import java.util.List; +import java.util.Map; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import com.linkedin.avro.fastserde.generated.avro.AnotherSubRecord; +import com.linkedin.avro.fastserde.generated.avro.StringableRecord; +import com.linkedin.avro.fastserde.generated.avro.StringableSubRecord; +import org.apache.avro.io.Encoder; +import org.apache.avro.util.Utf8; + +public class StringableRecord_SpecificSerializer_842267318 + implements FastSerializer +{ + + + public void serialize(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeStringableRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((BigInteger) data.get(0)).toString()); + serialize_StringableRecord0(data, (encoder), (customization)); + serialize_StringableRecord1(data, (encoder), (customization)); + serialize_StringableRecord2(data, (encoder), (customization)); + serialize_StringableRecord3(data, (encoder), (customization)); + serialize_StringableRecord4(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord0(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((BigDecimal) data.get(1)).toString()); + (encoder).writeString(((URI) data.get(2)).toString()); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord1(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((URL) data.get(3)).toString()); + (encoder).writeString(((File) data.get(4)).toString()); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord2(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List urlArray0 = ((List ) data.get(5)); + (encoder).writeArrayStart(); + if ((urlArray0 == null)||urlArray0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(urlArray0 .size()); + for (int counter0 = 0; (counter0 urlMap0 = ((Map ) data.get(6)); + if (((customization)!= null)&&((customization).getCheckMapTypeFunction()!= null)) { + (customization).getCheckMapTypeFunction().apply(urlMap0); + } + (encoder).writeMapStart(); + if ((urlMap0 == null)||urlMap0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(urlMap0 .size()); + for (URL key0 : ((Map ) urlMap0).keySet()) { + (encoder).startItem(); + String keyString0 = key0 .toString(); + (encoder).writeString(keyString0); + (encoder).writeString(((BigInteger) urlMap0 .get(key0)).toString()); + } + } + (encoder).writeMapEnd(); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord3(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord0 = ((StringableSubRecord) data.get(7)); + serializeStringableSubRecord0(subRecord0, (encoder), (customization)); + AnotherSubRecord subRecordWithSubRecord0 = ((AnotherSubRecord) data.get(8)); + serializeAnotherSubRecord0(subRecordWithSubRecord0, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeStringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + (encoder).writeString(((URI) data.get(0)).toString()); + serialize_StringableSubRecord0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableSubRecord0(StringableSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + Object nullStringIntUnion0 = ((Object) data.get(1)); + if (nullStringIntUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + if (nullStringIntUnion0 instanceof CharSequence) { + (encoder).writeIndex(1); + if (((CharSequence) nullStringIntUnion0) instanceof Utf8) { + (encoder).writeString(((Utf8)((CharSequence) nullStringIntUnion0))); + } else { + (encoder).writeString(((CharSequence) nullStringIntUnion0).toString()); + } + } else { + if (nullStringIntUnion0 instanceof Integer) { + (encoder).writeIndex(2); + (encoder).writeInt(((Integer) nullStringIntUnion0)); + } + } + } + } + + @SuppressWarnings("unchecked") + public void serializeAnotherSubRecord0(AnotherSubRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + StringableSubRecord subRecord1 = ((StringableSubRecord) data.get(0)); + serializeStringableSubRecord0(subRecord1, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + private void serialize_StringableRecord4(StringableRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + String stringUnion0 = ((String) data.get(9)); + if (stringUnion0 == null) { + (encoder).writeIndex(0); + (encoder).writeNull(); + } else { + (encoder).writeIndex(1); + (encoder).writeString(((String) stringUnion0).toString()); + } + } + +} diff --git a/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/TestArrayOfFloats_GenericSerializer_1408566797.java b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/TestArrayOfFloats_GenericSerializer_1408566797.java new file mode 100644 index 000000000..00818dce5 --- /dev/null +++ b/fastserde/avro-fastserde-tests19/build/codegen/java/com/linkedin/avro/fastserde/generated/serialization/AVRO_1_9/TestArrayOfFloats_GenericSerializer_1408566797.java @@ -0,0 +1,56 @@ + +package com.linkedin.avro.fastserde.generated.serialization.AVRO_1_9; + +import java.io.IOException; +import java.util.List; +import com.linkedin.avro.api.PrimitiveFloatList; +import com.linkedin.avro.fastserde.BufferBackedPrimitiveFloatList; +import com.linkedin.avro.fastserde.FastSerializer; +import com.linkedin.avro.fastserde.customized.DatumWriterCustomization; +import org.apache.avro.generic.IndexedRecord; +import org.apache.avro.io.Encoder; + +public class TestArrayOfFloats_GenericSerializer_1408566797 + implements FastSerializer +{ + + + public void serialize(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + serializeTestArrayOfFloats0(data, (encoder), (customization)); + } + + @SuppressWarnings("unchecked") + public void serializeTestArrayOfFloats0(IndexedRecord data, Encoder encoder, DatumWriterCustomization customization) + throws IOException + { + List array_of_float0 = ((List ) data.get(0)); + (encoder).writeArrayStart(); + if ((array_of_float0 == null)||array_of_float0 .isEmpty()) { + (encoder).setItemCount(0); + } else { + (encoder).setItemCount(array_of_float0 .size()); + Object array0 = array_of_float0; + if (array0 instanceof PrimitiveFloatList) { + PrimitiveFloatList primitiveList0 = ((PrimitiveFloatList) array0); + if (primitiveList0 instanceof BufferBackedPrimitiveFloatList) { + BufferBackedPrimitiveFloatList bufferBackedPrimitiveFloatList = ((BufferBackedPrimitiveFloatList) primitiveList0); + bufferBackedPrimitiveFloatList.writeFloats((encoder)); + } else { + for (int counter0 = 0; (counter0